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 MainPatternSearch_Part(bool EntirePart, ref List <MyGroupingSurface> listOfMyGroupingSurface,
List <MyGroupingSurface> listOfInitialGroupingSurface, ref StringBuilder fileOutput, SldWorks mySwApplication)
{
var listOfOutputPattern = new List <MyPattern>(); //list of output patterns found
var listOfOutputPatternTwo = new List <MyPattern>(); //list of output patterns of length 2 found
var toleranceOK = true; //it is TRUE if the tolerance level is OK during the paths searching, FALSE otherwise
while (listOfMyGroupingSurface.Count > 0 && toleranceOK == true)
{
MyGroupingSurface currentGroupingSurface;
if (!EntirePart)
{
currentGroupingSurface =
new MyGroupingSurface(listOfMyGroupingSurface[0].groupingSurface,
listOfMyGroupingSurface[0].listOfREOfGS);
}
else
{
currentGroupingSurface = new MyGroupingSurface(listOfMyGroupingSurface[0].KLplanareSurface,
listOfMyGroupingSurface[0].listOfREOfGS);
}
listOfMyGroupingSurface.RemoveAt(0);
fileOutput.AppendLine(" ");
fileOutput.AppendLine("(Al momento sono rimaste " + listOfMyGroupingSurface.Count +
" superfici, compresa questa.)");
PartUtilities.GeometryAnalysis.FindPatternsInGS(currentGroupingSurface, ref fileOutput,
ref listOfOutputPattern, ref listOfMyGroupingSurface,
ref listOfOutputPatternTwo, ref toleranceOK, listOfInitialGroupingSurface);
}
//Assigning of id numbers to the found MyPattern
//(the id will be used in composed pattern search phase)
//At the same time, we draw the pattern centroids
ModelDoc2 SwModel = mySwApplication.ActiveDoc;
SwModel.ClearSelection2(true);
SwModel.Insert3DSketch();
var i = 0;
foreach (var pattern in listOfOutputPattern)
{
pattern.idMyPattern = i;
i++;
var listOfCentroidsOfPattern = pattern.listOfMyREOfMyPattern.Select(re => re.centroid).ToList();
var patternCentroid = ExtractInfoFromBRep.computeCentroidsOfVertices(listOfCentroidsOfPattern);
pattern.patternCentroid = patternCentroid;
//SwModel.CreatePoint2(pattern.patternCentroid.x, pattern.patternCentroid.y, pattern.patternCentroid.z);
}
foreach (var pattern in listOfOutputPatternTwo)
{
pattern.idMyPattern = i;
i++;
var listOfCentroidsOfPattern = pattern.listOfMyREOfMyPattern.Select(re => re.centroid).ToList();
var patternCentroid = ExtractInfoFromBRep.computeCentroidsOfVertices(listOfCentroidsOfPattern);
pattern.patternCentroid = patternCentroid;
//SwModel.CreatePoint2(pattern.patternCentroid.x, pattern.patternCentroid.y, pattern.patternCentroid.z);
}
//SwModel.InsertSketch();
//Patterns are subdivided in Line patterns and in Circle patterns:
var listOfOutputPatternLine = new List <MyPattern>();
var listOfOutputPatternCircum = new List <MyPattern>();
foreach (var pattern in listOfOutputPattern)
{
if (pattern.pathOfMyPattern.GetType() == typeof(MyLine))
{
listOfOutputPatternLine.Add(pattern);
}
else
{
listOfOutputPatternCircum.Add(pattern);
}
}
//The results are shown giving color to the model:
ColorFace.MyVisualOutput(listOfOutputPatternLine, mySwApplication);
ColorFace.MyVisualOutput(listOfOutputPatternCircum, mySwApplication);
//The same for patterns of length 2:
ColorFace.MyVisualOutput(listOfOutputPatternTwo, mySwApplication);
//Build the list of MyGroupingSurfaceForPatterns:
var listOfGroupingSurfaceForPatterns = new List <MyGroupingSurfaceForPatterns>();
if (!EntirePart)
{
foreach (var gs in listOfInitialGroupingSurface)
{
var listOfPatternsLineForThisGS = listOfOutputPatternLine.FindAll(
pattern => pattern.listOfGroupingSurfaces.FindIndex(
surface => ExtractInfoFromBRep.MyEqualsSurface(surface, gs.groupingSurface, mySwApplication)) !=
-1);
var listOfPatternsTwoForThisGS = listOfOutputPatternTwo.FindAll(
pattern => pattern.listOfGroupingSurfaces.FindIndex(
surface => ExtractInfoFromBRep.MyEqualsSurface(surface, gs.groupingSurface, mySwApplication)) !=
-1);
listOfPatternsLineForThisGS.AddRange(listOfPatternsTwoForThisGS);
var listOfPatternsCircumForThisGS = listOfOutputPatternCircum.FindAll(
pattern => pattern.listOfGroupingSurfaces.FindIndex(
surface => ExtractInfoFromBRep.MyEqualsSurface(surface, gs.groupingSurface, mySwApplication)) !=
-1);
if (listOfPatternsLineForThisGS.Count > 1 || listOfPatternsCircumForThisGS.Count > 1)
{
var newGSForPatterns = new MyGroupingSurfaceForPatterns(gs.groupingSurface,
listOfPatternsLineForThisGS, listOfPatternsCircumForThisGS);
listOfGroupingSurfaceForPatterns.Add(newGSForPatterns);
}
}
}
//>>>>>>>COMPOSED PATTERN SEARCH:
List <MyComposedPattern> listOfOutputComposedPattern;
List <MyComposedPattern> listOfOutputComposedPatternTwo;
PartUtilities_ComposedPatterns.GeometryAnalysis.FindComposedPatterns(listOfGroupingSurfaceForPatterns, out listOfOutputComposedPattern,
out listOfOutputComposedPatternTwo, SwModel, mySwApplication, ref fileOutput);
ColorFace.MyVisualOutput_ComposedPatterns(listOfOutputComposedPattern,
listOfOutputComposedPatternTwo, mySwApplication, SwModel);
}