public static void FindComposedPatternsOfComponents( List <MyPatternOfComponents> listOfPatternsOfComponentsLine, List <MyPatternOfComponents> listOfPatternsOfComponentsCircum, out List <MyComposedPatternOfComponents> listOfOutputComposedPattern, out List <MyComposedPatternOfComponents> listOfOutputComposedPatternTwo, ModelDoc2 SwModel, SldWorks mySwApplication, ref StringBuilder fileOutput) { var toleranceOk = true; var listOfComposedPattern = new List <MyComposedPatternOfComponents>(); var listOfComposedPatternTwo = new List <MyComposedPatternOfComponents>(); // >>>>>>> LINEAR CASE: //first I group patterns by same length and same distance: var listOfListsOfCoherentPatternsLine = GroupFoundPatternsOfComponentsOfTypeLine( listOfPatternsOfComponentsLine, mySwApplication); //Then I group coherent patterns in subgroups of parallel patterns: foreach (var list in listOfListsOfCoherentPatternsLine) { //Grouping in lists of parallel patterns var listOfListsOfParallelPatterns = GroupPatternsOfComponentsInParallel(list); var numOfListsOfParallelPatterns = listOfListsOfParallelPatterns.Count; if (list.Count == 2) { //I verify if a composed pattern with these 2 patterns has already been created //in another GS: if (ComposedPatternOfComponentsOfLength2AlreadyExists(listOfComposedPatternTwo, list) == false) { //if a composed pattern does not exist yet AND //the 2 patterns are not parallel, I verify if it is REFLECTION: if (numOfListsOfParallelPatterns == 0) { //if (IsReflectionTwoPatterns(list[0], list[1])) //{ // KLdebug.Print("I 2 Pattern sono legate da RIFLESSIONE!", nameFile); // var typeOfNewComposedPattern = "Composed REFLECTION of length 2"; // BuildNewComposedPatternOfLength2(fileOutput, typeOfNewComposedPattern, // ref listOfComposedPattern, ref listOfComposedPatternTwo, // ref listOfGroupingSurfaceForPatterns, list); //} } else //if a composed pattern does not exist yet AND //the 2 patterns are parallel, I verify if it is TRANSLATION: { if (IsTranslationTwoPatternsOfComponents(list[0], list[1])) { var typeOfNewComposedPattern = "Composed TRANSLATION of length 2"; BuildNewComposedPatternOfComponentsOfLength2(fileOutput, typeOfNewComposedPattern, ref listOfComposedPattern, ref listOfComposedPatternTwo, list); } } } } else { foreach (var listOfParallelPatterns in listOfListsOfParallelPatterns) { if (listOfParallelPatterns.Count == 2) { //I verify if a composed pattern with these 2 patterns has already been created //in another GS: if (ComposedPatternOfComponentsOfLength2AlreadyExists(listOfComposedPatternTwo, list)) { } else { if (IsTranslationTwoPatternsOfComponents(listOfParallelPatterns[0], listOfParallelPatterns[1])) { var typeOfNewComposedPattern = "Composed TRANSLATION of length 2"; BuildNewComposedPatternOfComponentsOfLength2(fileOutput, typeOfNewComposedPattern, ref listOfComposedPattern, ref listOfComposedPatternTwo, listOfParallelPatterns); } } } else //(listOfParallelPatterns.Count > 2) { var listOfPatternCentroids = listOfParallelPatterns.Select(pattern => pattern.patternCentroid).ToList(); fileOutput.AppendLine(""); fileOutput.AppendLine(" >>>> CREATION OF ADJECENCY MATRICES FOR COMPOSED PATTERNS:"); var listOfMyMatrAdj = Functions.CreateMatrAdj(listOfPatternCentroids, ref fileOutput); var maxPath = false; //it is TRUE if the maximum Pattern is found, FALSE otherwise. while (listOfMyMatrAdj.Count > 0 && maxPath == false && toleranceOk) { var currentMatrAdj = new MyMatrAdj(listOfMyMatrAdj[0].d, listOfMyMatrAdj[0].matr, listOfMyMatrAdj[0].nOccur); listOfMyMatrAdj.Remove(listOfMyMatrAdj[0]); //NOTA: forse la mia MatrAdj non deve essere rimossa ma conservata, //soprattutto nel caso in cui si presenta onlyShortPath = true //(non avrebbe senso cancellarla, ma conservarla per la ricerca di path //di 2 RE). List <MyPathOfPoints> listOfPathsOfCentroids; bool onlyShortPaths; maxPath = PathCreation_Assembly_ComposedPatterns.Functions.FindPaths_Assembly_ComposedPatterns(currentMatrAdj, listOfParallelPatterns, ref fileOutput, out listOfPathsOfCentroids, out onlyShortPaths, ref toleranceOk, ref listOfMyMatrAdj, ref listOfComposedPattern, ref listOfComposedPatternTwo, SwModel, mySwApplication); if (toleranceOk) { if (listOfPathsOfCentroids != null) { if (maxPath == false) { if (onlyShortPaths == false) { GetComposedPatternsFromListOfPathsLine_Assembly(listOfPathsOfCentroids, listOfParallelPatterns, ref listOfMyMatrAdj, ref listOfComposedPattern, ref listOfComposedPatternTwo, mySwApplication, ref fileOutput); } else { //non faccio niente e li rimetto in gioco per } } } } else { listOfOutputComposedPattern = listOfComposedPattern; listOfOutputComposedPatternTwo = listOfComposedPatternTwo; return; } } } } //Now coherent linear patterns that have not been set in a composed pattern yet //are examined to see if they consitute any rotation composed pattern: list.RemoveAll( pattern => listOfComposedPattern.FindIndex( composedPattern => composedPattern.ListOfMyPatternOfComponents.FindIndex( patternInComposedPattern => patternInComposedPattern.idMyPattern == pattern.idMyPattern) != -1) != -1); if (list.Count != 0) { if (list.Count == 2) { // >>> POSSIBLE REFLECTION CAN EXIST //I verify if a composed pattern with these 2 patterns has already been created //in another GS: if (ComposedPatternOfComponentsOfLength2AlreadyExists(listOfComposedPatternTwo, list)) { } } else { var listOfPatternCentroids1 = list.Select(pattern => pattern.patternCentroid).ToList(); fileOutput.AppendLine(""); fileOutput.AppendLine(" >>>> CREATION OF ADJECENCY MATRICES FOR COMPOSED PATTERNS:"); var listOfMyMatrAdj1 = Functions.CreateMatrAdj(listOfPatternCentroids1, ref fileOutput); var maxPath = false; //it is TRUE if the maximum Pattern is found, FALSE otherwise. while (listOfMyMatrAdj1.Count > 0 && maxPath == false && toleranceOk) { var currentMatrAdj = new MyMatrAdj(listOfMyMatrAdj1[0].d, listOfMyMatrAdj1[0].matr, listOfMyMatrAdj1[0].nOccur); listOfMyMatrAdj1.Remove(listOfMyMatrAdj1[0]); //NOTA: forse la mia MatrAdj non deve essere rimossa ma conservata, //soprattutto nel caso in cui si presenta onlyShortPath = true //(non avrebbe senso cancellarla, ma conservarla per la ricerca di path //di 2 RE). List <MyPathOfPoints> listOfPathsOfCentroids1; bool onlyShortPaths1; var maxPath1 = PathCreation_Assembly_ComposedPatterns.Functions.FindPaths_Assembly_ComposedPatterns(currentMatrAdj, list, ref fileOutput, out listOfPathsOfCentroids1, out onlyShortPaths1, ref toleranceOk, ref listOfMyMatrAdj1, ref listOfComposedPattern, ref listOfComposedPatternTwo, SwModel, mySwApplication); if (toleranceOk) { if (listOfPathsOfCentroids1 != null) { //I ignore every linear path (I look for composed rotational patterns now): var listOfCircularPaths = listOfPathsOfCentroids1.FindAll( path => path.pathGeometricObject.GetType() == typeof(MyCircumForPath)) .ToList(); if (maxPath1 == false) { if (onlyShortPaths1 == false) { GetComposedPatternsFromListOfPathsLine_Assembly(listOfCircularPaths, list, ref listOfMyMatrAdj1, ref listOfComposedPattern, ref listOfComposedPatternTwo, mySwApplication, ref fileOutput); } else { //non faccio niente e li rimetto in gioco per } } } } } } } } } listOfOutputComposedPattern = listOfComposedPattern; listOfOutputComposedPatternTwo = listOfComposedPatternTwo; }
public static void FindComposedPatterns(List <MyGroupingSurfaceForPatterns> listOfGroupingSurfaceForPatterns, out List <MyComposedPattern> listOfOutputComposedPattern, out List <MyComposedPattern> listOfOutputComposedPatternTwo, ModelDoc2 SwModel, SldWorks mySwApplication, ref StringBuilder fileOutput) { var toleranceOk = true; var listOfComposedPattern = new List <MyComposedPattern>(); var listOfComposedPatternTwo = new List <MyComposedPattern>(); //For each MyGroupingSurfaceForPatterns while (listOfGroupingSurfaceForPatterns.Count > 0 && toleranceOk) { var currentGroupingSurfaceForPatterns = new MyGroupingSurfaceForPatterns( listOfGroupingSurfaceForPatterns[0].groupingSurface, listOfGroupingSurfaceForPatterns[0].listOfPatternsLine, listOfGroupingSurfaceForPatterns[0].listOfPatternsCircum); listOfGroupingSurfaceForPatterns.RemoveAt(0); fileOutput.AppendLine(""); fileOutput.AppendLine("NUOVA SURFACE OF TYPE: " + currentGroupingSurfaceForPatterns.groupingSurface.Identity()); fileOutput.AppendLine("(Al momento sono rimaste ancora " + listOfGroupingSurfaceForPatterns.Count + " superfici (oltre questa).)"); // >>>>>>> LINEAR CASE: //first I group patterns by same length and same distance: var listOfListsOfCoherentPatternsLine = GroupFoundPatternsOfTypeLine( currentGroupingSurfaceForPatterns.listOfPatternsLine, mySwApplication); if (listOfListsOfCoherentPatternsLine.Count == 0) { } //Then I group coherent patterns in subgroups of parallel patterns: foreach (var list in listOfListsOfCoherentPatternsLine) { //Grouping in lists of parallel patterns var listOfListsOfParallelPatterns = GroupPatternsInParallel(list); var numOfListsOfParallelPatterns = listOfListsOfParallelPatterns.Count; if (list.Count == 2) { //I verify if a composed pattern with these 2 patterns has already been created //in another GS: if (ComposedPatternOfLength2AlreadyExists(listOfComposedPatternTwo, list) == false) { //if a composed pattern does not exist yet AND //the 2 patterns are not parallel, I verify if it is REFLECTION: if (numOfListsOfParallelPatterns == 0) { if (IsReflectionTwoPatterns(list[0], list[1])) { var typeOfNewComposedPattern = "Composed REFLECTION of length 2"; BuildNewComposedPatternOfLength2(fileOutput, typeOfNewComposedPattern, ref listOfComposedPattern, ref listOfComposedPatternTwo, ref listOfGroupingSurfaceForPatterns, list); } } else //if a composed pattern does not exist yet AND //the 2 patterns are parallel, I verify if it is TRANSLARION: { if (IsTranslationTwoPatterns(list[0], list[1])) { var typeOfNewComposedPattern = "Composed TRANSLATION of length 2"; BuildNewComposedPatternOfLength2(fileOutput, typeOfNewComposedPattern, ref listOfComposedPattern, ref listOfComposedPatternTwo, ref listOfGroupingSurfaceForPatterns, list); } else { if (IsReflectionTwoPatterns(list[0], list[1])) { var typeOfNewComposedPattern = "Composed REFLECTION of length 2"; BuildNewComposedPatternOfLength2(fileOutput, typeOfNewComposedPattern, ref listOfComposedPattern, ref listOfComposedPatternTwo, ref listOfGroupingSurfaceForPatterns, list); } } } } } else { foreach (var listOfParallelPatterns in listOfListsOfParallelPatterns) { if (listOfParallelPatterns.Count == 2) { //I verify if a composed pattern with these 2 patterns has already been created //in another GS: if (ComposedPatternOfLength2AlreadyExists(listOfComposedPatternTwo, list)) { } else { if (IsTranslationTwoPatterns(listOfParallelPatterns[0], listOfParallelPatterns[1])) { var typeOfNewComposedPattern = "Composed TRANSLATION of length 2"; BuildNewComposedPatternOfLength2(fileOutput, typeOfNewComposedPattern, ref listOfComposedPattern, ref listOfComposedPatternTwo, ref listOfGroupingSurfaceForPatterns, listOfParallelPatterns); } else { if (IsReflectionTwoPatterns(list[0], list[1])) { var typeOfNewComposedPattern = "Composed REFLECTION of length 2"; BuildNewComposedPatternOfLength2(fileOutput, typeOfNewComposedPattern, ref listOfComposedPattern, ref listOfComposedPatternTwo, ref listOfGroupingSurfaceForPatterns, list); } } } } else //(listOfParallelPatterns.Count > 2) { var listOfPatternCentroids = listOfParallelPatterns.Select(pattern => pattern.patternCentroid).ToList(); fileOutput.AppendLine(""); fileOutput.AppendLine(" >>>> CREATION OF ADJECENCY MATRICES FOR COMPOSED PATTERNS:"); var listOfMyMatrAdj = Functions.CreateMatrAdj(listOfPatternCentroids, ref fileOutput); var maxPath = false; //it is TRUE if the maximum Pattern is found, FALSE otherwise. while (listOfMyMatrAdj.Count > 0 && maxPath == false && toleranceOk) { var currentMatrAdj = new MyMatrAdj(listOfMyMatrAdj[0].d, listOfMyMatrAdj[0].matr, listOfMyMatrAdj[0].nOccur); listOfMyMatrAdj.Remove(listOfMyMatrAdj[0]); //NOTA: forse la mia MatrAdj non deve essere rimossa ma conservata, //soprattutto nel caso in cui si presenta onlyShortPath = true //(non avrebbe senso cancellarla, ma conservarla per la ricerca di path //di 2 RE). List <MyPathOfPoints> listOfPathsOfCentroids; bool onlyShortPaths; maxPath = PathCreation_Part_ComposedPatterns.Functions.FindPaths_ComposedPatterns(currentMatrAdj, listOfParallelPatterns, ref fileOutput, out listOfPathsOfCentroids, out onlyShortPaths, ref toleranceOk, ref listOfMyMatrAdj, ref listOfGroupingSurfaceForPatterns, ref listOfComposedPattern, ref listOfComposedPatternTwo, mySwApplication); //fileOutput.AppendLine("listOfPathOfCentroids.Count = " + listOfPathOfCentroids.Count, nameFile); if (toleranceOk) { if (listOfPathsOfCentroids != null) { if (maxPath == false) { if (onlyShortPaths == false) { GetComposedPatternsFromListOfPathsLine(listOfPathsOfCentroids, listOfParallelPatterns, ref listOfMyMatrAdj, ref listOfGroupingSurfaceForPatterns, ref listOfComposedPattern, ref listOfComposedPatternTwo, mySwApplication, ref fileOutput); } else { //non faccio niente e li rimetto in gioco per } } } } } } } //Now coherent linear patterns that have not been set in a composed pattern yet //are examined to see if they consitute any rotation composed pattern: list.RemoveAll( pattern => listOfComposedPattern.FindIndex( composedPattern => composedPattern.listOfMyPattern.FindIndex( patternInComposedPattern => patternInComposedPattern.idMyPattern == pattern.idMyPattern) != -1) != -1); if (list.Count != 0) { if (list.Count == 2) { // >>> POSSIBLE REFLECTION CAN EXIST //I verify if a composed pattern with these 2 patterns has already been created //in another GS: if (ComposedPatternOfLength2AlreadyExists(listOfComposedPatternTwo, list)) { } else { if (IsReflectionTwoPatterns(list[0], list[1])) { var typeOfNewComposedPattern = "Composed REFLECTION of length 2"; BuildNewComposedPatternOfLength2(fileOutput, typeOfNewComposedPattern, ref listOfComposedPattern, ref listOfComposedPatternTwo, ref listOfGroupingSurfaceForPatterns, list); } } } else { var listOfPatternCentroids1 = list.Select(pattern => pattern.patternCentroid).ToList(); fileOutput.AppendLine(""); fileOutput.AppendLine(" >>>> CREATION OF ADJECENCY MATRICES FOR COMPOSED PATTERNS:"); var listOfMyMatrAdj1 = Functions.CreateMatrAdj(listOfPatternCentroids1, ref fileOutput); var maxPath = false; //it is TRUE if the maximum Pattern is found, FALSE otherwise. while (listOfMyMatrAdj1.Count > 0 && maxPath == false && toleranceOk) { var currentMatrAdj = new MyMatrAdj(listOfMyMatrAdj1[0].d, listOfMyMatrAdj1[0].matr, listOfMyMatrAdj1[0].nOccur); listOfMyMatrAdj1.Remove(listOfMyMatrAdj1[0]); //NOTA: forse la mia MatrAdj non deve essere rimossa ma conservata, //soprattutto nel caso in cui si presenta onlyShortPath = true //(non avrebbe senso cancellarla, ma conservarla per la ricerca di path //di 2 RE). List <MyPathOfPoints> listOfPathsOfCentroids1; bool onlyShortPaths1; var maxPath1 = PathCreation_Part_ComposedPatterns.Functions.FindPaths_ComposedPatterns(currentMatrAdj, list, ref fileOutput, out listOfPathsOfCentroids1, out onlyShortPaths1, ref toleranceOk, ref listOfMyMatrAdj1, ref listOfGroupingSurfaceForPatterns, ref listOfComposedPattern, ref listOfComposedPatternTwo, mySwApplication); if (toleranceOk) { if (listOfPathsOfCentroids1 != null) { //I ignore every linear path (I look for composed rotational patterns now): var listOfCircularPaths = listOfPathsOfCentroids1.FindAll( path => path.pathGeometricObject.GetType() == typeof(MyCircumForPath)) .ToList(); if (maxPath1 == false) { if (onlyShortPaths1 == false) { GetComposedPatternsFromListOfPathsLine(listOfCircularPaths, list, ref listOfMyMatrAdj1, ref listOfGroupingSurfaceForPatterns, ref listOfComposedPattern, ref listOfComposedPatternTwo, mySwApplication, ref fileOutput); } else { //non faccio niente e li rimetto in gioco per } } } } } } } } } // >>>>>>> CIRCULAR CASE: #region da rivedere //first I group patterns by same length and same distance: var listOfListsOfCoherentPatternsCircum = GroupFoundPatternsOfTypeCircum( currentGroupingSurfaceForPatterns.listOfPatternsCircum, mySwApplication); //Then I group coherent patterns in subgroups of patterns: foreach (var list in listOfListsOfCoherentPatternsCircum) { var listOfListsOfPatternsWithSameCenterAndPlane = GroupPatternsWithSameCenterPlane(list); var numOfListsOfParallelPatterns = listOfListsOfPatternsWithSameCenterAndPlane.Count; //Grouping in lists of parallel patterns foreach (var listOfPatternsWithSameCenterAndPlane in listOfListsOfPatternsWithSameCenterAndPlane) { if (listOfPatternsWithSameCenterAndPlane.Count == 2) { if (IsTranslationTwoPatterns(listOfPatternsWithSameCenterAndPlane[0], listOfPatternsWithSameCenterAndPlane[1])) { var typeOfNewComposedPattern = "Composed ROTATIONAL (same center) of length 2"; BuildNewComposedPatternOfLength2(fileOutput, typeOfNewComposedPattern, ref listOfComposedPattern, ref listOfComposedPatternTwo, ref listOfGroupingSurfaceForPatterns, listOfPatternsWithSameCenterAndPlane); } } else //listOfPatternsWithSameCenterAndPlane.Count > 2 { // var listOfPatternCentroids = // listOfPatternsWithSameCenterAndPlane.Select(pattern => pattern.patternCentroid).ToList(); // KLdebug.Print("", nameFile); // KLdebug.Print(" >>>> CREATION OF ADJECENCY MATRICES FOR COMPOSED PATTERNS:", nameFile); // var listOfMyMatrAdj = Functions.CreateMatrAdj(listOfPatternCentroids, ref fileOutput); // var indOfMatr = 0; // List<MyPathOfPoints> listOfPathsOfCentroids; // bool onlyShortPaths; // ////////////// // var maxPath = Functions.FindPaths_ComposedPatterns(listOfMyMatrAdj[indOfMatr], listOfPatternsWithSameCenterAndPlane, // ref fileOutput, out listOfPathsOfCentroids, out onlyShortPaths, ref toleranceOk, ref listOfMyMatrAdj, // ref listOfGroupingSurfaceForPatterns, ref listOfComposedPattern, ref listOfComposedPatternTwo); // if (toleranceOk) // { // if (maxPath == false) // { // if (onlyShortPaths == false) // { // GetComposedPatternsFromListOfPathsLine(listOfPathsOfCentroids, // listOfPatternsWithSameCenterAndPlane, // ref listOfMyMatrAdj, ref listOfGroupingSurfaceForPatterns, // ref listOfComposedPattern, ref listOfComposedPatternTwo); // } // else // { // //non faccio niente e li rimetto in gioco per // } // } // } // else // { // KLdebug.Print("===>> TOLLERANZA NON SUFFICIENTEMENTE PICCOLA. TERMINATO.", nameFile); // } } } } } #endregion listOfOutputComposedPattern = listOfComposedPattern; listOfOutputComposedPatternTwo = listOfComposedPatternTwo; }
public static void KLFindPatternsOfComponents(List <MyRepeatedComponent> listOfComponents, List <MyVertex> listOfVertexOrigins, ref List <MyPatternOfComponents> listOfMyPattern, ref List <MyPatternOfComponents> listOfMyPatternTwo, ModelDoc2 SwModel, SldWorks swApplication, ref StringBuilder fileOutput) { //per PROVA: parto dal livello delle foglie... //I create a list of adjacency matrices at constant distance. //The constant distance is the distance between the origin of the coordinate systems //(it is computed by computing the Euclidean norm of the difference vector between // two origins). var numOfComponents = listOfComponents.Count; //var listOfVertexOrigins = listOfComponents.Select(component2 => component2.Origin).ToList(); //foreach (MyVertex origin in listOfVertexOrigins) //{ // var centroidToPrint = string.Format("{0}, {1}, {2}", origin.x, origin.y, origin.z); // //KLdebug.Print(centroidToPrint, "Centroidi.txt"); //} if (numOfComponents > 2) { //fileOutput.AppendLine("CREAZIONE MATRICI DI ADIACENZA:"); var maxPath = false; //it is TRUE if the maximum Pattern is found, FALSE otherwise. var toleranceOk = true; var listOfMyMatrAdj = Functions.CreateMatrAdj(listOfVertexOrigins, ref fileOutput); while (listOfMyMatrAdj.Count > 0 && maxPath == false && toleranceOk == true) { bool onlyShortPath; var currentMatrAdj = new MyMatrAdj(listOfMyMatrAdj[0].d, listOfMyMatrAdj[0].matr, listOfMyMatrAdj[0].nOccur); //fileOutput.AppendLine("Esamino NUOVA MatrAdj. Al momento sono rimaste " + listOfMyMatrAdj.Count + // " MatrAdj."); listOfMyMatrAdj.Remove(listOfMyMatrAdj[0]); //NOTA: forse la mia MatrAdj non deve essere rimossa ma conservata, //soprattutto nel caso in cui si presenta onlyShortPath = true //(non avrebbe senso cancellarla, ma conservarla per la ricerca di path //di 2 RE). //fileOutput.AppendLine("----> Eliminata NUOVA MatrAdj. Ora sono rimaste " + listOfMyMatrAdj.Count + // " MatrAdj."); //fileOutput.AppendLine(" "); List <MyPathOfPoints> listOfPathOfPoints; maxPath = PathCreation_Assembly.Functions.KLFindPaths_Assembly(currentMatrAdj, listOfComponents, listOfVertexOrigins, ref fileOutput, out listOfPathOfPoints, out onlyShortPath, ref toleranceOk, ref listOfMyMatrAdj, ref listOfMyPattern, ref listOfMyPatternTwo, SwModel, swApplication); //fileOutput.AppendLine(" "); //fileOutput.AppendLine("PER QUESTA MATRADJ: "); //fileOutput.AppendLine("maxPath = " + maxPath); //fileOutput.AppendLine("listOfMyPattern.Count = " + listOfMyPattern.Count); //fileOutput.AppendLine("listOfMyPatternTwo.Count = " + listOfMyPatternTwo.Count); //fileOutput.AppendLine("onlyShortPath = " + onlyShortPath); //fileOutput.AppendLine("toleranceOK = " + toleranceOk); if (toleranceOk == true) { if (listOfPathOfPoints != null) { if (maxPath == false) { if (onlyShortPath == false) { GeometryAnalysis.KLGetPatternsFromListOfPaths_Assembly(listOfPathOfPoints, listOfComponents, listOfVertexOrigins, ref listOfMyMatrAdj, ref listOfMyPattern, ref listOfMyPatternTwo, SwModel, swApplication); } else { //non faccio niente e li rimetto in gioco per } } } else { fileOutput.AppendLine(" ---> NO PATH FOUND in this adjacency matrix!"); } } else { fileOutput.AppendLine("===>> TOLLERANZA NON SUFFICIENTEMENTE PICCOLA. TERMINATO."); } } } else { if (numOfComponents == 2) { //fileOutput.AppendLine("LE COMPONENTI DI QUESTO TIPO SONO 2: "); if (Part.PartUtilities.GeometryAnalysis.IsTranslationTwoRE(listOfComponents[0].RepeatedEntity, listOfComponents[1].RepeatedEntity)) { // fileOutput.AppendLine("Le due COMPONENTI sono legate da TRASLAZIONE!"); var listOfPathOfCentroids = new List <MyPathOfPoints>(); var listOfMyMatrAdj = new List <MyMatrAdj>(); var newPatternRC = new List <MyRepeatedComponent> { listOfComponents[0], listOfComponents[1] }; if (listOfVertexOrigins.Count < 2) { swApplication.SendMsgToUser("Non ho due origini"); } var newPatternGeomObject = FunctionsLC.LinePassingThrough(listOfVertexOrigins[0], listOfVertexOrigins[1]); var newPatternType = "TRANSLATION of length 2"; var newPattern = new MyPatternOfComponents(newPatternRC, newPatternGeomObject, newPatternType); GeometryAnalysis.KLCheckAndUpdate_Assembly(newPattern, ref listOfPathOfCentroids, listOfVertexOrigins, ref listOfMyMatrAdj, ref listOfMyPattern, ref listOfMyPatternTwo); //swApplication.SendMsgToUser("Pattern da due " + listOfMyPatternTwo.Count); } else { if (Part.PartUtilities.GeometryAnalysis.IsReflectionTwoRE(listOfComponents[0].RepeatedEntity, listOfComponents[1].RepeatedEntity, swApplication)) { //fileOutput.AppendLine("Le due COMPONENTI sono legate da RIFLESSIONE!"); var listOfPathOfCentroids = new List <MyPathOfPoints>(); var listOfMyMatrAdj = new List <MyMatrAdj>(); var newPatternRC = new List <MyRepeatedComponent> { listOfComponents[0], listOfComponents[1] }; var newPatternGeomObject = FunctionsLC.LinePassingThrough(listOfVertexOrigins[0], listOfVertexOrigins[1]); var newPatternType = "REFLECTION"; var newPattern = new MyPatternOfComponents(newPatternRC, newPatternGeomObject, newPatternType); GeometryAnalysis.KLCheckAndUpdate_Assembly(newPattern, ref listOfPathOfCentroids, listOfVertexOrigins, ref listOfMyMatrAdj, ref listOfMyPattern, ref listOfMyPatternTwo); } //else //{ // fileOutput.AppendLine("PROVO CON LA ROTAZIONE:"); // double[] axisDirection; // if (GeometryAnalysis.IsRotationTwoComp180degrees_Assembly(listOfComponents[0], listOfComponents[1], // out axisDirection, SwModel, swApplication)) // { // fileOutput.AppendLine("Le due COMPONENTI sono legate da ROTAZIONE!"); // var listOfPathOfCentroids = new List<MyPathOfPoints>(); // var listOfMyMatrAdj = new List<MyMatrAdj>(); // var newPatternRC = new List<MyRepeatedComponent> // { // listOfComponents[0], // listOfComponents[1] // }; // var angle90degrees = Math.PI / 2; // var thirdVertexOnCircum = listOfVertexOrigins[0].Rotate(angle90degrees, axisDirection); // var newPatternGeomObject = FunctionsLC.CircumPassingThrough(listOfVertexOrigins[0], listOfVertexOrigins[1], thirdVertexOnCircum, ref fileOutput); // var newPatternType = "ROTATION"; // var newPattern = new MyPatternOfComponents(newPatternRC, newPatternGeomObject, newPatternType); // GeometryAnalysis.KLCheckAndUpdate_Assembly(newPattern, ref listOfPathOfCentroids, // listOfVertexOrigins, ref listOfMyMatrAdj, // ref listOfMyPattern, ref listOfMyPatternTwo); // } //} } } } }
//PRIMA DI USARE QUESTO METODO RICORDARSI DI ELIMINARE LA CURRENTgROUPINGSURFACE DALLA LISTA!!!! public static void FindPatternsInGS(MyGroupingSurface currentGroupingSurface, ref StringBuilder fileOutput, ref List <MyPattern> listOfMyPattern, ref List <MyGroupingSurface> listOfMyGroupingSurface, ref List <MyPattern> listOfMyPatternTwo, ref bool toleranceOK, List <MyGroupingSurface> listOfInitialGroupingSurface) { var ListOfREOnThisSurface = currentGroupingSurface.listOfREOfGS.Select(myRepeatedEntity => myRepeatedEntity).ToList(); var listOfCentroidsThisGS = currentGroupingSurface.listOfREOfGS.Select(myRepeatedEntity => myRepeatedEntity.centroid).ToList(); var numOfCentroidsOnThisGS = listOfCentroidsThisGS.Count; var maxPath = false; //it is TRUE if the maximum Pattern is found, FALSE otherwise. if (numOfCentroidsOnThisGS > 2) { List <MyMatrAdj> listOfMyMatrAdj = Functions.CreateMatrAdj(listOfCentroidsThisGS, ref fileOutput); while (listOfMyMatrAdj.Count > 0 && maxPath == false && toleranceOK == true) { bool onlyShortPath; var currentMatrAdj = new MyMatrAdj(listOfMyMatrAdj[0].d, listOfMyMatrAdj[0].matr, listOfMyMatrAdj[0].nOccur); listOfMyMatrAdj.Remove(listOfMyMatrAdj[0]); //NOTA: forse la mia MatrAdj non deve essere rimossa ma conservata, //soprattutto nel caso in cui si presenta onlyShortPath = true //(non avrebbe senso cancellarla, ma conservarla per la ricerca di path //di 2 RE). fileOutput.AppendLine("----> Considero NUOVA MatrAdj. Sono rimaste ancora " + listOfMyMatrAdj.Count + " MatrAdj da controllare."); fileOutput.AppendLine(" "); List <MyPathOfPoints> listOfPathOfCentroids; maxPath = Functions.FindPaths(currentMatrAdj, ListOfREOnThisSurface, ref fileOutput, out listOfPathOfCentroids, out onlyShortPath, ref toleranceOK, ref listOfMyMatrAdj, ref listOfMyGroupingSurface, listOfInitialGroupingSurface, ref listOfMyPattern, ref listOfMyPatternTwo); fileOutput.AppendLine(" "); fileOutput.AppendLine("PER QUESTA MATRADJ prima della ricerca 'ufficiale' di pattern': "); fileOutput.AppendLine("maxPath = " + maxPath); fileOutput.AppendLine("listOfMyPattern.Count = " + listOfMyPattern.Count); fileOutput.AppendLine("listOfMyPatternTwo.Count = " + listOfMyPatternTwo.Count); fileOutput.AppendLine("onlyShortPath = " + onlyShortPath); fileOutput.AppendLine("toleranceOK = " + toleranceOK); //fileOutput.AppendLine("listOfPathOfCentroids.Count = " + listOfPathOfCentroids.Count); if (toleranceOK == true) { if (listOfPathOfCentroids != null) { if (maxPath == false) { if (onlyShortPath == false) { GetPatternsFromListOfPaths(listOfPathOfCentroids, ListOfREOnThisSurface, ref listOfMyMatrAdj, ref listOfMyGroupingSurface, listOfInitialGroupingSurface, ref listOfMyPattern, ref listOfMyPatternTwo); } else { //non faccio niente e li rimetto in gioco per } } } else { fileOutput.AppendLine(" ---> NO PATH FOUND in this adjacency matrix!"); } } else { fileOutput.AppendLine("===>> TOLLERANZA NON SUFFICIENTEMENTE PICCOLA. TERMINATO."); return; } } } else { //numOfCentroidsOnThisGS = 2 if (numOfCentroidsOnThisGS == 2) { fileOutput.AppendLine("Su QUESTA GS ci sono solo 2 RE: "); if (IsTranslationTwoRE(ListOfREOnThisSurface[0], ListOfREOnThisSurface[1])) { fileOutput.AppendLine("Le due RE sono legate da TRASLAZIONE!"); var listOfPathOfCentroids = new List <MyPathOfPoints>(); var listOfMyMatrAdj = new List <MyMatrAdj>(); var newPatternRE = new List <MyRepeatedEntity>(); newPatternRE.Add(ListOfREOnThisSurface[0]); newPatternRE.Add(ListOfREOnThisSurface[1]); var newPatternGeomObject = FunctionsLC.LinePassingThrough(listOfCentroidsThisGS[0], listOfCentroidsThisGS[1]); var newPatternType = "TRANSLATION of length 2"; var listOfGroupingSurfaceForThisPattern = findGroupingSurfacesForThisPattern(listOfInitialGroupingSurface, newPatternRE, numOfCentroidsOnThisGS); var newPattern = new MyPattern(newPatternRE, newPatternGeomObject, newPatternType, listOfGroupingSurfaceForThisPattern); CheckAndUpdate(newPattern, ref listOfPathOfCentroids, ListOfREOnThisSurface, ref listOfMyMatrAdj, ref listOfMyGroupingSurface, ref listOfMyPattern, ref listOfMyPatternTwo); } else { if (IsReflectionTwoRE(ListOfREOnThisSurface[0], ListOfREOnThisSurface[1], null)) { fileOutput.AppendLine("Le due RE sono legate da RIFLESSIONE!"); var listOfPathOfCentroids = new List <MyPathOfPoints>(); var listOfMyMatrAdj = new List <MyMatrAdj>(); var newPatternRE = new List <MyRepeatedEntity>(); newPatternRE.Add(ListOfREOnThisSurface[0]); newPatternRE.Add(ListOfREOnThisSurface[1]); var newPatternGeomObject = FunctionsLC.LinePassingThrough(listOfCentroidsThisGS[0], listOfCentroidsThisGS[1]); var newPatternType = "REFLECTION"; var listOfGroupingSurfaceForThisPattern = findGroupingSurfacesForThisPattern(listOfInitialGroupingSurface, newPatternRE, numOfCentroidsOnThisGS); var newPattern = new MyPattern(newPatternRE, newPatternGeomObject, newPatternType, listOfGroupingSurfaceForThisPattern); CheckAndUpdate(newPattern, ref listOfPathOfCentroids, ListOfREOnThisSurface, ref listOfMyMatrAdj, ref listOfMyGroupingSurface, ref listOfMyPattern, ref listOfMyPatternTwo); } } } } }