/// <summary>
/// Находит новые паттерны и вхождения существующих.
/// </summary>
/// <param name="newPatterns">Новые паттерны</param>
/// <returns>true, если найдены новые паттерны, и false в противном случае</returns>
public bool FindPatterns(out PatternMap newPatterns)
{
newPatterns = new PatternMap(matrix);
var coveredVertices = new List <string>();
for (int n = matrix.Vertices - 1; n > 2; n--)
{
newPatterns[n] = PatternsOfSize(n, coveredVertices);
KnownPatterns[n].AddRange(newPatterns[n]);
filterer.RemoveIntersectingWithBiggerPatterns(n);
selector.SelectInstances(n);
filterer.RemoveSingletons(n);
var vertices = (from pattern in newPatterns[n]
from instance in pattern.Instances
from vertex in instance.Vertices
select vertex).Distinct();
coveredVertices.AddRange(vertices);
}
return(!newPatterns.IsEmpty);
}
private static void Export(PatternMap patterns, int iteration)
{
using (var writer = new StreamWriter(PATH, true))
{
writer.WriteLine("--- Итерация " + iteration + " ---");
for (int n = patterns.MaxPatternSize; n > 2; n--)
{
foreach (var pattern in patterns[n])
{
if (pattern.Instances.Count == 0)
{
continue;
}
writer.WriteLine("Паттерн: " + pattern.Name);
int index = 1;
foreach (var instance in pattern.Instances)
{
string vertices = string.Join(", ", instance.Vertices);
writer.WriteLine(index + ") " + vertices);
index++;
}
writer.WriteLine();
}
}
}
}
internal PatternConverter(string dotNetPattern, RegexOptions options)
{
DotNetPattern = dotNetPattern;
var isIgnorePatternWhitespace = (options & RegexOptions.IgnorePatternWhitespace) == RegexOptions.IgnorePatternWhitespace;
var isExpicitCapture = (options & RegexOptions.ExplicitCapture) == RegexOptions.ExplicitCapture;
var parser = new PatternParser(dotNetPattern, isIgnorePatternWhitespace, isExpicitCapture);
var parseItems = parser.Parse();
patternMap = new PatternMap(parseItems);
var builder = new PatternBuilder(dotNetPattern, patternMap);
JavaPattern = builder.Build(parseItems);
}
public GraphAnalyzer(Graph graph, PatternMap patterns = null)
{
this.graph = graph;
matrix = AdjacencyMatrix.FromGraph(graph);
invariants = matrix.GetInvariantGroups();
KnownPatterns = patterns ?? new PatternMap(matrix);
if (patterns != null)
{
KnownPatterns.ClearInstances();
}
filterer = new PatternFilterer(KnownPatterns);
selector = new PatternSelector(KnownPatterns);
}
internal PatternConverter(string dotNetPattern, RegexOptions options)
{
DotNetPattern = dotNetPattern;
var isIgnorePatternWhitespace = (options & RegexOptions.IgnorePatternWhitespace) == RegexOptions.IgnorePatternWhitespace;
var isExpicitCapture = (options & RegexOptions.ExplicitCapture) == RegexOptions.ExplicitCapture;
var parser = new PatternParser(dotNetPattern, isIgnorePatternWhitespace, isExpicitCapture);
var parseItems = parser.Parse();
patternMap = new PatternMap(parseItems);
var builder = new PatternBuilder(dotNetPattern, patternMap);
JavaPattern = builder.Build(parseItems);
}
static void Main(string[] args)
{
Image sampleImage = Image.FromFile("Path of the sample.");
Bitmap sampleBitmap = new Bitmap(sampleImage);
Color[,] colorMap = new Color[sampleBitmap.Width, sampleBitmap.Height]; //Making a 2D array of T
for (int y = 0; y < sampleBitmap.Height; y++)
{
for (int x = 0; x < sampleBitmap.Width; x++)
{
colorMap[x, y] = sampleBitmap.GetPixel(x, y);
}
}
MapConverter <Color> mapConverter = new MapConverter <Color>(); //Claas for converting this 2D array of T in usable int 2D array
mapConverter.Init(colorMap);
int[,] map = mapConverter.Convert(colorMap); //The usable 2D array
PatternMap patternMap = new PatternMap(map, sampleBitmap.Width);
patternMap.FindPatterns(3); //Pattern of size 3 (so here 3 pixel per pattern)
patternMap.GetPatternsNeighbor(); //^&<- Finding pattern and their rules
WfcSolver solver = new WfcSolver(patternMap, 4269101);
int[,] output = solver.Run(25); //Generate a output of 25x25 size (25 x 25 pattern so 75 * 75 pixel)
Color[,] result = mapConverter.Convert(patternMap.Convert(output, 25)); //Convert it back to a pattern -> int -> color array
Bitmap resultBitmap = new Bitmap(result.GetLength(0), result.GetLength(1));
for (int y = 0; y < result.GetLength(1); y++)
{
for (int x = 0; x < result.GetLength(0); x++)
{
resultBitmap.SetPixel(x, y, result[x, y]);
}
}
resultBitmap.Save("Path for saving result.", System.Drawing.Imaging.ImageFormat.Png);
}
internal static void Process(Graph graph)
{
int iteration = 1;
bool foundPatterns;
PatternMap patterns = null;
if (File.Exists(PATH))
{
File.Delete(PATH);
}
do
{
Console.WriteLine("\nИтерация №" + iteration);
if (graph.VertexCount < 3)
{
Console.WriteLine("Граф имеет слишком мало вершин для поиска паттернов.");
break;
}
Console.WriteLine("Ищем паттерны...");
var analyzer = new GraphAnalyzer(graph, patterns);
foundPatterns = analyzer.FindPatterns(out patterns);
if (foundPatterns)
{
Console.WriteLine("Найдено экземпляров паттернов: " + patterns.TotalInstances);
Console.WriteLine("Делаем подстановку...");
graph.ReplacePatterns(patterns);
Export(patterns, iteration);
iteration++;
}
else
{
Console.WriteLine("Паттернов не обнаружено.");
}
} while (foundPatterns);
Console.WriteLine("Поиск завершён.");
}
public override string Replacement(string pattern, PatternMap map)
{
//convert into numbered capture group
return "(";
}
public override string Replacement(string pattern, PatternMap map)
{
//remove
return string.Empty;
}
public void Initialize(List <WordMatch> patterns, bool bCaseSensitive = false, bool bIncludeSpecialCharacters = false, bool bIncludeExtendedAscii = false)
{
_patterns = patterns;
k = patterns.Count;
m = 0; // start with 0 and grow from there
for (var i = 0; i < k; ++i)
{
var lenPattern = patterns[i].Word.Length;
if (B > lenPattern)
{
throw new Exception("found pattern less than B in length");
}
m = (0 == m) ? lenPattern : Math.Min(m, lenPattern);
}
m_nSizeOfAlphabet = (char)1; // at minimum we have a white space character
for (var i = 0; i <= 255; ++i)
{
m_lu[i].Letter = ' '; // table is defaulted to whitespace
m_lu[i].Offset = (char)0; //
if ((i >= 'a') && (i <= 'z'))
{
m_lu[i].Letter = (char)i; // no problems with lower case letters
m_lu[i].Offset = m_nSizeOfAlphabet++;
}
if (bCaseSensitive)
{
// case of !bCaseSensitive fixed up later on
if ((i >= 'A') && (i <= 'Z'))
{
m_lu[i].Letter = (char)i; // map upper case to lower case
m_lu[i].Offset = m_nSizeOfAlphabet++;
}
}
if ((i >= '0') && (i <= '9'))
{
m_lu[i].Letter = (char)i; // use digits
m_lu[i].Offset = m_nSizeOfAlphabet++;
}
}
if (!bCaseSensitive)
{
// fix up upper case mappings ( uppercase comes before lower case in ascii table )
for (var i = (short)'A'; i <= 'Z'; ++i)
{
char letter = (char)(i - (short)'A' + (short)'a'); // map upper case to lower case
m_lu[i].Letter = letter; // map upper case to lower case
m_lu[i].Offset = m_lu[letter].Offset;
// no unique characters so don't increment size
}
}
if (bIncludeSpecialCharacters)
{
for (var i = 0; i < rchSpecialCharacters.Length; i++)
{
var c = rchSpecialCharacters[i];
m_lu[c].Letter = c;
m_lu[c].Offset = m_nSizeOfAlphabet++;
}
}
if (bIncludeExtendedAscii)
{
for (var i = 0; i < rchExtendedAscii.Length; i++)
{
var c = rchExtendedAscii[i];
m_lu[c].Letter = c;
m_lu[c].Offset = m_nSizeOfAlphabet++;
}
}
m_nBitsInShift = Convert.ToInt16(Math.Ceiling(Math.Log((double)m_nSizeOfAlphabet) / Math.Log((double)2)));
// can use fewer bits in shift to turn it into a hash
m_nTableSize = Convert.ToInt32(Math.Pow(Math.Pow((double)2, m_nBitsInShift), (int)B));
// 2 ** bits ** B, will be some unused space when not hashed
m_ShiftTable = new int[m_nTableSize];
for (var i = 0; i < m_nTableSize; ++i)
{
m_ShiftTable[i] = m - B + 1; // default to m-B+1 for shift
}
m_vPatternMap = new Dictionary <int, List <PatternMap> >();
for (var j = 0; j < k; ++j)
{
// loop through patterns
for (var q = m; q >= B; --q)
{
int hash;
hash = m_lu[patterns[j].Word[q - 2 - 1]].Offset; // bring in offsets of X in pattern j
hash <<= m_nBitsInShift;
hash += m_lu[patterns[j].Word[q - 1 - 1]].Offset;
hash <<= m_nBitsInShift;
hash += m_lu[patterns[j].Word[q - 1]].Offset;
var shiftlen = m - q;
m_ShiftTable[hash] = Math.Min(m_ShiftTable[hash], shiftlen);
if (0 == shiftlen)
{
var m_PatternMapElement = new PatternMap();
m_PatternMapElement.Index = j;
m_PatternMapElement.PrefixHash = m_lu[patterns[j].Word[0]].Offset;
m_PatternMapElement.PrefixHash <<= m_nBitsInShift;
m_PatternMapElement.PrefixHash += m_lu[patterns[j].Word[1]].Offset;
if (!m_vPatternMap.TryGetValue(hash, out var map))
{
m_vPatternMap.Add(hash, new List <PatternMap>());
}
m_vPatternMap[hash].Add(m_PatternMapElement);
}
}
}
m_vPatternMap.TrimExcess();
m_bInitialized = true;
}
public PatternMap FindPatterns(GoBoard goBoard, Color playerToMove, List<int> legalMoves)
{
PatternMap lPatternMap = new PatternMap(goBoard, playerToMove);
if (DFAMatrix == null)
return lPatternMap;
foreach (int lOrigin in legalMoves)
{
int lState = 1;
Coordinate lStart = new Coordinate(goBoard.Coord.GetColumn(lOrigin), goBoard.Coord.GetRow(lOrigin));
Coordinate lSpiral = new Coordinate(0, 0);
while (true)
{
Coordinate lAt = lStart + lSpiral;
lSpiral.SpiralNext();
char c = '#';
if (lAt.IsOnBoard(goBoard.BoardSize))
{
c = goBoard.GetColor(goBoard.Coord.At(lAt.X, lAt.Y)).ToChar();
if (playerToMove.IsBlack)
{
// patterns are stored in white moves next
// so flip colors when is black's turn
if (c == 'O') c = 'X'; else if (c == 'X') c = 'O';
}
}
lState = DFAMatrix.GetPatterns(lState, c, lPatternMap, lStart, lOrigin);
if (lState == 0)
break;
}
}
return lPatternMap;
}
public override string Replacement(string pattern, PatternMap map)
{
var number = map.GroupNumberFromName(Name);
return(string.Format("\\{0}", map.GetSourceToTargetsIndex(number)[0]));
}
public override string Replacement(string pattern, PatternMap map)
{
throw new NotSupportedException("Conditions are not supported in dot42");
}
public override string Replacement(string pattern, PatternMap map)
{
return string.Format("\\{0}", map.GetSourceToTargetsIndex(Number)[0]);
}
public override string Replacement(string pattern, PatternMap map)
{
//convert into numbered capture group
return("(");
}
public virtual string Replacement(string pattern, PatternMap map)
{
return(pattern.Substring(StartIndex, EndIndex - StartIndex));
}
public virtual string Replacement(string pattern, PatternMap map)
{
return pattern.Substring(StartIndex, EndIndex - StartIndex);
}
public override string Replacement(string pattern, PatternMap map)
{
//remove
return(string.Empty);
}
public override string Replacement(string pattern, PatternMap map)
{
throw new NotSupportedException("Conditions are not supported in dot42");
}
public override string Replacement(string pattern, PatternMap map)
{
return(string.Format("\\{0}", map.GetSourceToTargetsIndex(Number)[0]));
}
public PatternSelector(PatternMap patterns)
{
this.patterns = patterns;
}
public PatternFilterer(PatternMap patternMap)
{
this.patternMap = patternMap;
}
public override string Replacement(string pattern, PatternMap map)
{
var number = map.GroupNumberFromName(Name);
return string.Format("\\{0}", map.GetSourceToTargetsIndex(number)[0]);
}
