private void FVmeshSingleColor(MatNode fv) { Vector3[] vertices = MatrixToVectorArray(fv.Fields["vertices"].GetValue <double[, ]>()); int[] faces = MatrixTo1DArray(fv.Fields["faces"].GetValue <int[, ]>()); Color color = GetColor(fv.Fields["color"].GetValue <double[, ]>()); _mesh = new Mesh(); _mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32; _mesh.vertices = vertices; _mesh.triangles = faces; _mesh.RecalculateNormals(); double[,] temp = fv.Fields["opacity"].GetValue <double[, ]>(); float _opacity = (float)temp[0, 0]; if (_opacity < 1f) { meshInstance = Instantiate(_singelColorMeshPrefab, new Vector3(0, 0, 0), Quaternion.identity); meshInstance.GetComponent <Renderer>().material.SetFloat("_opacity", _opacity); } else { meshInstance = Instantiate(_opaqueSingleColorPrefab, new Vector3(0, 0, 0), Quaternion.identity); } meshInstance.GetComponent <Renderer>().material.SetColor("_color", color); meshInstance.transform.parent = transform; meshInstance.GetComponent <MeshFilter>().mesh = _mesh; meshInstance.GetComponent <MeshCollider>().sharedMesh = _mesh; }
public void SetGridObject(int x, int y, MatNode value) { if (x >= 0 && y > 0 && x < largeur && y < hauteur) { listNode[x, y] = value; } }
private void FVmeshVertexColor(MatNode fv) { Vector3[] vertices = MatrixToVectorArray(fv.Fields["vertices"].GetValue <double[, ]>()); int[] faces = MatrixTo1DArray(fv.Fields["faces"].GetValue <int[, ]>()); double[,] col = fv.Fields["colors"].GetValue <double[, ]>(); _mesh = new Mesh(); _mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32; _mesh.vertices = vertices; _mesh.triangles = faces; _mesh.RecalculateNormals(); UnityEngine.Gradient colMap = MatrixToColormap(fv.Fields["map"].GetValue <double[, ]>()); Color[] vertexColors = GetVertexColors(col, colMap, 0); _mesh.colors = vertexColors; double[,] temp = fv.Fields["opacity"].GetValue <double[, ]>(); float _opacity = (float)temp[0, 0]; if (_opacity < 1) { meshInstance = Instantiate(_vertexColorMeshPrefab, new Vector3(0, 0, 0), Quaternion.identity); meshInstance.GetComponent <Renderer>().material.SetFloat("_opacity", _opacity); } else { meshInstance = Instantiate(_opaqueVertexColorPrefab, new Vector3(0, 0, 0), Quaternion.identity); } meshInstance.transform.parent = transform; meshInstance.GetComponent <MeshFilter>().mesh = _mesh; //passing the mesh to the MeshFilteere so it can be displayed meshInstance.GetComponent <MeshCollider>().sharedMesh = _mesh; //adding _mesh to MeshCollider so it can be hit by raycasts (and do other collider physics) }
// public void setPosJ(Vector3 posJ) // { // positionJoueur = posJ; // } // public Vector3 getPosJ() // { // return positionJoueur; //} public void SetGridObject(Vector3 worldPosition, MatNode value) { int x, y; GetXY(worldPosition, out x, out y); SetGridObject(x, y, value); }
private int CalculerLaDistanceEntreNode(MatNode a, MatNode b) { int DistanceX = Mathf.Abs(a.x - b.x); int DistanceY = Mathf.Abs(a.y - b.y); int restant = Mathf.Abs(DistanceX - DistanceY); return(COUT_MOUVEMENT_DIAGONAL * Mathf.Min(DistanceX, DistanceY) + COUT_MOUVEMENT_DROIT * restant); }
private void drawGraph(MatNode gr) { Color color = ColorParser.GetColor(gr.Fields["color"].GetValue <double[, ]>()); double[,] x = gr.Fields["x"].GetValue <double[, ]>(); double[,] y = gr.Fields["y"].GetValue <double[, ]>(); List <Vector2[]> points = DataParser.buildPointsList(x, y); graphContainer.GetComponent <GraphController>().BuildGraph(points, color); }
public FigureDataStructList(string _path) { DataStructList = new List <FigureDataStruct>(); MatReader inputMatReader = new MatReader(_path); MatNode inputMatNode = inputMatReader.Fields[inputMatReader.FieldNames[0]]; foreach (var field in inputMatNode.Fields) { MatNode _struct = inputMatNode.Fields[field.Key]; DataStructList.Add(new FigureDataStruct(_struct)); // read all variables in this node and add to list } }
private MatNode CalculerLowerFcost(List <MatNode> listNode) { MatNode lowerFCostNode = listNode[0]; for (int i = 0; i < listNode.Count; i++) { if (listNode[i].Fcost < lowerFCostNode.Fcost) { lowerFCostNode = listNode[i]; } } return(lowerFCostNode); }
// matType Functions private void FVmeshSingleColor(MatNode fv) { Vector3[] vertices = DataParser.MatrixToVectorArray(fv.Fields["vertices"].GetValue <double[, ]>()); int[] faces = DataParser.MatrixTo1DArray(fv.Fields["faces"].GetValue <int[, ]>()); GameObject meshInstance = BuilderFunctions.InstantiateMesh(vertices, faces, transform); Color color = ColorParser.GetColor(fv.Fields["color"].GetValue <double[, ]>()); double[,] temp = fv.Fields["opacity"].GetValue <double[, ]>(); float opacity = (float)temp[0, 0]; BuilderFunctions.AddMat(opacity, meshInstance, _singleColor, _opaqueSingleColor); meshInstance.GetComponent <MeshRenderer>().material.SetColor("_color", color); }
public List <MatNode> CalculerPathNode(MatNode endNode) { List <MatNode> chemin = new List <MatNode>(); chemin.Add(endNode); MatNode nodeActuelle = endNode; while (nodeActuelle.cameFromNode != null) { chemin.Add(nodeActuelle.cameFromNode); nodeActuelle = nodeActuelle.cameFromNode; } chemin.Reverse(); return(chemin); }
public void UpdateMatlabFigure() { DestroyAllChildren(); SliderCanvas.SetActive(false); MatReader matFileReader = new MatReader(Application.streamingAssetsPath + Path.DirectorySeparatorChar + fileSelectionDropDown.Text); MatNode matFile = matFileReader.Fields[matFileReader.FieldNames[0]]; foreach (var field in matFile.Fields) { MatNode _struct = matFile.Fields[field.Key]; int[,] _type = _struct.Fields["type"].GetValue <int[, ]>(); switch (_type[0, 0]) { case 1: // type 1 = FV triangulated mesh FVmeshVertexColor(_struct); break; case 2: // type 2 = 3D scatter scatter3(_struct); break; case 3: // multiple vertex color mesh FVmeshMultiVertColor(_struct); break; case 4: // inset graph; drawGraph(_struct); break; // should add options for multigraph case 5: // single color mesh FVmeshSingleColor(_struct); break; case 6: // set camera distance CamDistSetter(_struct); break; } } }
//private MatNode CalculerLowerFcost(List<MatNode> listNode) //{ // MatNode lowerFCostNode = listNode[0]; //// for (int i = 0; i < listNode.Count; i++) // { // if (listNode[i].Fcost < lowerFCostNode.Fcost) // { // lowerFCostNode = listNode[i]; // } // } // return lowerFCostNode; // } private MatNode CalculerPlusGrandFcost(List <MatNode> listNode) { // bool plusGrandeDistanceAtteinte = true; MatNode plusGrandFCostNode = listNode[0]; for (int i = 0; i < listNode.Count; i++) { if (listNode[i].Hcost >= plusGrandFCostNode.Hcost) { plusGrandFCostNode = listNode[i]; // plusGrandeDistanceAtteinte = false; } } // if (plusGrandeDistanceAtteinte == true) atteintCasePLusEloigné = true; return(plusGrandFCostNode); }
private List <MatNode> GetNodeVoisin(MatNode nodeActuelle) { List <MatNode> neighbourList = new List <MatNode>(); if (nodeActuelle.x - 1 >= 0) { // Left neighbourList.Add(grid.GetGridObject(nodeActuelle.x - 1, nodeActuelle.y)); // Left Down if (nodeActuelle.y - 1 >= 0) { neighbourList.Add(grid.GetGridObject(nodeActuelle.x - 1, nodeActuelle.y - 1)); } // Left Up if (nodeActuelle.y + 1 < grid.GetHauteur()) { neighbourList.Add(grid.GetGridObject(nodeActuelle.x - 1, nodeActuelle.y + 1)); } } if (nodeActuelle.x + 1 < grid.GetLargueur()) { // Right neighbourList.Add(grid.GetGridObject(nodeActuelle.x + 1, nodeActuelle.y)); // Right Down if (nodeActuelle.y - 1 >= 0) { neighbourList.Add(grid.GetGridObject(nodeActuelle.x + 1, nodeActuelle.y - 1)); } // Right Up if (nodeActuelle.y + 1 < grid.GetHauteur()) { neighbourList.Add(grid.GetGridObject(nodeActuelle.x + 1, nodeActuelle.y + 1)); } } // Down if (nodeActuelle.y - 1 >= 0) { neighbourList.Add(grid.GetGridObject(nodeActuelle.x, nodeActuelle.y - 1)); } // Up if (nodeActuelle.y + 1 < grid.GetHauteur()) { neighbourList.Add(grid.GetGridObject(nodeActuelle.x, nodeActuelle.y + 1)); } return(neighbourList); }
private void FVmeshMultiVertColor(MatNode fv) { SliderCanvas.SetActive(true); Vector3[] vertices = MatrixToVectorArray(fv.Fields["vertices"].GetValue <double[, ]>()); int[] faces = MatrixTo1DArray(fv.Fields["faces"].GetValue <int[, ]>()); double[,] col = fv.Fields["colors"].GetValue <double[, ]>(); _multicolorMesh = new Mesh(); _multicolorMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32; _multicolorMesh.vertices = vertices; _multicolorMesh.triangles = faces; _multicolorMesh.RecalculateNormals(); slider.maxValue = col.GetLength(1) - 1; slider.value = 0; UnityEngine.Gradient colMap = MatrixToColormap(fv.Fields["map"].GetValue <double[, ]>()); vertexColorList = new List <Color[]>(); for (int i = 0; i < col.GetLength(1); i++) { vertexColorList.Add(GetVertexColors(col, colMap, i)); } _multicolorMesh.colors = vertexColorList[0]; double[,] temp = fv.Fields["opacity"].GetValue <double[, ]>(); float _opacity = (float)temp[0, 0]; if (_opacity < 1) { _multicolorFV = Instantiate(_vertexColorMeshPrefab, new Vector3(0, 0, 0), Quaternion.identity); _multicolorFV.GetComponent <Renderer>().material.SetFloat("_opacity", _opacity); } else { _multicolorFV = Instantiate(_opaqueVertexColorPrefab, new Vector3(0, 0, 0), Quaternion.identity); } _multicolorFV.transform.parent = transform; _multicolorFV.GetComponent <MeshFilter>().mesh = _multicolorMesh; _multicolorFV.GetComponent <MeshCollider>().sharedMesh = _multicolorMesh; }
private void FVmeshVertexColor(MatNode fv) { Vector3[] vertices = DataParser.MatrixToVectorArray(fv.Fields["vertices"].GetValue <double[, ]>()); int[] faces = DataParser.MatrixTo1DArray(fv.Fields["faces"].GetValue <int[, ]>()); GameObject meshInstance = BuilderFunctions.InstantiateMesh(vertices, faces, transform); double[,] temp = fv.Fields["opacity"].GetValue <double[, ]>(); float opacity = (float)temp[0, 0]; BuilderFunctions.AddMat(opacity, meshInstance, _vertexColors, _opaqueVertexColors); double[,] col = fv.Fields["colors"].GetValue <double[, ]>(); List <Color[]> vertexColorList = ColorParser.GetVertexColorList(col, fv.Fields["map"].GetValue <double[, ]>()); meshInstance.GetComponent <MeshFilter>().mesh.colors = vertexColorList[0]; }
public MatFileReader_firstTest(MatNode matNode) { // this is a bit of a silly workaround to get a string read in to be the key "_type", but using strings as keys for _matTypes is going to maake this whole script much more readable. // Accord throws an error if _struct is a Matlab struct with both numeric arrays and strings // so type is a struct with one field. The field contains no data but the FieldName is the sting I am trying to pass. _type = _type = new List <string>(matNode.Fields["type"].Fields.Keys)[0]; foreach (string str in _fieldsToRead) { if (matNode.Fields.ContainsKey(str)) { _hh += str + " here\n"; continue; } _absent += str + " missing\n"; } }
private static void HandleConnectionDictionaries(MatNode matNode) { if (matNode.Fields.ContainsKey("DirectConnections")) { foreach (string target_id in matNode.Fields["DirectConnections"].Fields.Keys) { // is this efficient to add straight to the dictionary in ShootManager...? // or would it be better to build a temp Dictionary here and add the whole dictionary to shootmanager... ShootManager.DirectConnectionDictionary.Add(target_id, DataParser.IntMatrixTo1DStringArray(matNode.Fields["DirectConnections"].Fields[target_id].GetValue <int[, ]>(), prefix: "target_")); } } if (matNode.Fields.ContainsKey("IndirectConnections")) { foreach (string target_id in matNode.Fields["IndirectConnections"].Fields.Keys) { ShootManager.InDirectConnectionDictionary.Add(target_id, DataParser.IntMatrixTo1DStringArray(matNode.Fields["IndirectConnections"].Fields[target_id].GetValue <int[, ]>(), prefix: "target_")); } } }
public void UpdateMatlabFigure() { string _path = Application.streamingAssetsPath + Path.DirectorySeparatorChar + fileSelectionDropDown.Text; MatReader matFileReader = new MatReader(_path); MatNode matFile = matFileReader.Fields[matFileReader.FieldNames[0]]; foreach (var field in matFile.Fields) { MatNode _struct = matFile.Fields[field.Key]; // this is a bit of a silly workaround to get a string read in to be the key "_type", but using strings as keys for _matTypes is going to maake this whole script much more readable. // Accord throws an error if _struct is a Matlab struct with both numeric arrays and strings // so type is a struct with one field. The field contains no data but the FieldName is the sting I am trying to pass. string _type = new List <string>(_struct.Fields["type"].Fields.Keys)[0]; MatFileReader hmm = new MatFileReader(_struct); _matTypes[_type](_struct); } }
private void scatter3(MatNode sc) { GameObject scatterInstance = new GameObject("scatter3Container"); scatterInstance.transform.parent = transform; Vector3[] pts = DataParser.MatrixToVectorArray(sc.Fields["vertices"].GetValue <double[, ]>()); int[,] sz = sc.Fields["size"].GetValue <int[, ]>(); Color color = ColorParser.GetColor(sc.Fields["color"].GetValue <double[, ]>()); for (int i = 0; i < pts.GetLength(0); i++) { GameObject sp = GameObject.CreatePrimitive(PrimitiveType.Sphere); sp.transform.position = pts[i]; sp.transform.localScale = new Vector3(sz[0, i], sz[0, i], sz[0, i]); sp.GetComponent <Renderer>().material = _scatterMat; sp.GetComponent <Renderer>().material.SetColor("_BaseColor", color); sp.transform.parent = scatterInstance.transform; } }
public MatGrid(int n_largeur, int n_hauteur, float n_dimCell, Vector3 n_origine) { largeur = n_largeur; hauteur = n_hauteur; dimCell = n_dimCell; origine = n_origine; listNode = new MatNode[largeur, hauteur]; colliderList = GameObject.FindGameObjectsWithTag("Obstacle"); for (int x1 = 0; x1 < listNode.GetLength(0); x1++) { for (int y2 = 0; y2 < listNode.GetLength(1); y2++) { listNode[x1, y2] = new MatNode(x1, y2); for (int i = 0; i < colliderList.Length; i++) { GetXY(colliderList[i].transform.position, out int x, out int y); if (x1 == x & y2 == y) { listNode[x, y].obstacle = true; } } } } for (int x = 0; x < largeur; x++) { for (int y = 0; y < hauteur; y++) { Debug.DrawLine(Position(x, y), Position(x + 1, y), Color.white, 100f); Debug.DrawLine(Position(x, y), Position(x, y + 1), Color.white, 100f); } } Debug.DrawLine(Position(0, hauteur), Position(largeur, hauteur), Color.white, 100f); Debug.DrawLine(Position(largeur, 0), Position(largeur, hauteur), Color.white, 100f); }
private void drawGraph(MatNode gr) { GameObject _graph = Instantiate(graphPrefab, new Vector3(0, 0, 0), Quaternion.identity); _graph.transform.SetParent(graphContainer, false); UILineRenderer uILineRenderer = _graph.GetComponent <UILineRenderer>(); Color color = GetColor(gr.Fields["color"].GetValue <double[, ]>()); double[,] x = gr.Fields["x"].GetValue <double[, ]>(); double[,] y = gr.Fields["y"].GetValue <double[, ]>(); Vector2[] points = buildPointsArray(x, y, 0); uILineRenderer.color = color; uILineRenderer.Points = points; if (y.GetLength(1) > 1) // if graph has more than 1 set of y values it becomes scrollable { graphList.Add(uILineRenderer); _graphXvalues.Add(x); _graphYvalues.Add(y); } }
public FigureDataStruct(MatNode matNode) { Type = new List <string>(matNode.Fields["type"].Fields.Keys)[0]; // type MUST be defined for every input object that is why it is the only one not in an if statement if (Type == "ConnectionDictionary") { HandleConnectionDictionaries(matNode); } if (matNode.Fields.ContainsKey("vertices")) { Vertices = DataParser.MatrixToVectorArray(matNode.Fields["vertices"].GetValue <double[, ]>()); } if (matNode.Fields.ContainsKey("faces")) { Faces = DataParser.MatrixTo1DArray(matNode.Fields["faces"].GetValue <int[, ]>()); } if (matNode.Fields.ContainsKey("opacity")) { Opacity = (float)matNode.Fields["opacity"].GetValue <double[, ]>()[0, 0]; } if (matNode.Fields.ContainsKey("colors")) { double[,] colorArray = matNode.Fields["colors"].GetValue <double[, ]>(); VertColorList = DataParser.GetVertexColorList(colorArray, matNode.Fields["map"].GetValue <double[, ]>()); } if (matNode.Fields.ContainsKey("color")) { SingleColor = DataParser.GetColor(matNode.Fields["color"].GetValue <double[, ]>()); } if (matNode.Fields.ContainsKey("size")) { PointSize = DataParser.MatrixTo1DArray(matNode.Fields["size"].GetValue <int[, ]>()); } if (matNode.Fields.ContainsKey("camDistance")) { CamDistance = matNode.Fields["camDistance"].GetValue <int[, ]>()[0, 0]; } if (matNode.Fields.ContainsKey("x")) { if (matNode.Fields.ContainsKey("y")) // y should always be defined if x is... but just to check { GraphPointList = DataParser.buildPointsList(matNode.Fields["x"].GetValue <double[, ]>(), matNode.Fields["y"].GetValue <double[, ]>()); } } if (matNode.Fields.ContainsKey("shootability")) { shootability = DataParser.MatrixTo1DArray(matNode.Fields["shootability"].GetValue <int[, ]>()); } if (matNode.Fields.ContainsKey("id")) { id = DataParser.MatrixTo1DArray(matNode.Fields["id"].GetValue <int[, ]>()); } }
public List <MatNode> FindPath(int startX, int startY, int endX, int endY) { MatNode startNode = grid.GetGridObject(startX, startY); MatNode endNode = grid.GetGridObject(endX, endY); openList = new List <MatNode> { startNode }; closeList = new List <MatNode>(); for (int x = 0; x < grid.GetLargueur(); x++) { for (int y = 0; y < grid.GetHauteur(); y++) { MatNode node = grid.GetGridObject(x, y); node.Gcost = int.MaxValue; node.Hcost = 0; node.cameFromNode = null; node.CalculerFcost(); } } startNode.Gcost = 0; startNode.Hcost = CalculerLaDistanceEntreNode(startNode, endNode); startNode.CalculerFcost(); while (openList.Count > 0) { MatNode NodeActuelle = CalculerPlusGrandFcost(openList); limiteDistance++; if (limiteDistance >= 50) { return(CalculerPathNode(NodeActuelle)); //fin de la recherche } openList.Remove(NodeActuelle); closeList.Add(NodeActuelle); foreach (MatNode nodeVoisine in GetNodeVoisin(NodeActuelle)) { if (closeList.Contains(nodeVoisine)) { continue; } if (nodeVoisine.obstacle == true) { closeList.Add(nodeVoisine); continue; } int tempGcost = NodeActuelle.Gcost + CalculerLaDistanceEntreNode(NodeActuelle, nodeVoisine); if (tempGcost < nodeVoisine.Gcost) { nodeVoisine.Gcost = tempGcost; nodeVoisine.Hcost = CalculerLaDistanceEntreNode(nodeVoisine, endNode); nodeVoisine.cameFromNode = NodeActuelle; nodeVoisine.CalculerFcost(); if (!openList.Contains(nodeVoisine)) { openList.Add(nodeVoisine); } } } } //lorsque que la openlist est vide return(null); }
private void CamDistSetter(MatNode d) { int[,] _dist = d.Fields["camDistance"].GetValue <int[, ]>(); CamOrbit.functions.SetCamDistance(_dist[0, 0]); }
/// <summary> /// Creates a new <see cref="MatReader"/>. /// </summary> /// /// <param name="reader">A reader for input stream containing the MAT file.</param> /// <param name="autoTranspose">Pass <c>true</c> to automatically transpose matrices if they /// have been stored differently from .NET's default row-major order. Default is <c>true</c>.</param> /// public MatReader(BinaryReader reader, bool autoTranspose) { this.autoTranspose = autoTranspose; long startOffset = reader.BaseStream.Position; this.reader = reader; char[] title = reader.ReadChars(116); reader.ReadInt64(); // long subOffset short version = reader.ReadInt16(); char[] endian = reader.ReadChars(2); int terminator = Array.IndexOf(title, '\0'); if (terminator < 0) terminator = title.Length; Description = new String(title, 0, terminator).Trim(); Version = version; BigEndian = endian[0] == 'M'; if (BitConverter.IsLittleEndian && BigEndian) throw new NotSupportedException("The file bit ordering differs from the system architecture."); contents = new Dictionary<string, MatNode>(); while (true) { long offset = reader.BaseStream.Position; // Read first MAT data element MatDataTag elementTag; if (!reader.Read(out elementTag)) return; // Create a new node from the current position MatNode node = new MatNode(this, reader, offset, elementTag, true); // Advance the stream to the next element (might be removed in the future) reader.BaseStream.Seek(offset + elementTag.NumberOfBytes + 8, SeekOrigin.Begin); contents.Add(node.Name, node); } }