public byte[] GetOptimalStep(byte[,] playField, HashSet <byte[]> CellsToCheck, int depth) { Dictionary <byte[], int> iscores = new Dictionary <byte[], int>(); foreach (byte[] cell in CellsToCheck) { byte[,] b = (byte[, ])playField.Clone(); b[cell[0], cell[1]] = 1; int s = algorithm.Evaluate(b, cell, 1); iscores[cell] = s; } var items = from i in iscores orderby i.Value descending select new { coordinates = i.Key, estimation = i.Value }; var cellsToCheckList = items.Take(10).ToList(); if (cellsToCheckList[0].estimation > 430000) { return(cellsToCheckList[0].coordinates); } Dictionary <byte[], int> scores = new Dictionary <byte[], int>(); Parallel.ForEach(cellsToCheckList, cell => { int score = algorithm.EvaluateCell((byte[, ])playField.Clone(), cell.coordinates, 1, (byte)depth); lock (scores) { scores.Add(cell.coordinates, score); } }); var item = (from entry in scores orderby entry.Value descending select entry).FirstOrDefault(); return(item.Key); }
public IList <byte[, ]> Expand(byte[,] state) { IList <byte[, ]> ret = new List <byte[, ]>(); int x = -1, y = -1; int lenghtX = state.GetLength(0); int lenghtY = state.GetLength(1); for (int i = 0; i < lenghtX; i++) { for (int j = 0; j < lenghtY; j++) { if (state[i, j] == 0) { x = i; y = j; } } } if (x == -1 || y == -1) { throw new Exception(); } if (x + 1 < lenghtX) { byte[,] subRet = (byte[, ])state.Clone(); subRet[x, y] = subRet[x + 1, y]; subRet[x + 1, y] = 0; ret.Add(subRet); } if (x - 1 >= 0) { byte[,] subRet = (byte[, ])state.Clone(); subRet[x, y] = subRet[x - 1, y]; subRet[x - 1, y] = 0; ret.Add(subRet); } if (y + 1 < lenghtY) { byte[,] subRet = (byte[, ])state.Clone(); subRet[x, y] = subRet[x, y + 1]; subRet[x, y + 1] = 0; ret.Add(subRet); } if (y - 1 >= 0) { byte[,] subRet = (byte[, ])state.Clone(); subRet[x, y] = subRet[x, y - 1]; subRet[x, y - 1] = 0; ret.Add(subRet); } return(ret); }
//---------------- public IList <byte[, ]> Expand(byte[,] state) { int size = state.GetLength(0); int distance = CheckDistance(state); byte[] findZero = find(0, state); //znajdz lokalizacje pustego miejsca (0) byte[,] newState = new byte[size, size]; //kwadrat List <byte[, ]> ListOfNewStates = new List <byte[, ]>(4); //max. 4 mozliwosci byte x; if (findZero[1] > 0) { newState = (byte[, ])state.Clone(); x = state[findZero[0], findZero[1] - 1]; //wartosc ktora zamieniamy z zerem newState[findZero[0], findZero[1] - 1] = 0; // newstate[pierwsza koordynate zera, druga koordynata] newState[findZero[0], findZero[1]] = x; ListOfNewStates.Add(newState); } if (findZero[0] > 0) { newState = (byte[, ])state.Clone(); x = state[findZero[0] - 1, findZero[1]]; //wartosc ktora zamieniamy z zerem newState[findZero[0] - 1, findZero[1]] = 0; newState[findZero[0], findZero[1]] = x; ListOfNewStates.Add(newState); } if (findZero[0] < size - 1) { newState = (byte[, ])state.Clone(); x = state[findZero[0] + 1, findZero[1]]; //wartosc ktora zamieniamy z zerem newState[findZero[0] + 1, findZero[1]] = 0; newState[findZero[0], findZero[1]] = x; ListOfNewStates.Add(newState); } if (findZero[1] < size - 1) { newState = (byte[, ])state.Clone(); x = state[findZero[0], findZero[1] + 1]; //wartosc ktora zamieniamy z zerem newState[findZero[0], findZero[1] + 1] = 0; newState[findZero[0], findZero[1]] = x; ListOfNewStates.Add(newState); } return(ListOfNewStates); }
private byte[,] Skeleton(byte[,] originalBright, int border, byte brightness) { byte[,] erosenImg = (byte[, ])originalBright.Clone(); byte[,] OCbright; byte[,] res = new byte[pictureBox1.Width, pictureBox1.Height]; byte diff; int flag = 1; while (flag != 0) { flag = 0; erosenImg = EroseImage(erosenImg, border, 0); OCbright = OpeningClosing(erosenImg, border); for (int x = border; x < pictureBox1.Width - border; x++) { for (int y = border; y < pictureBox1.Height - border; y++) { diff = (byte)(erosenImg[x, y] - OCbright[x, y]); if (diff == brightness) { flag++; } res[x, y] += diff; } } } return(res); }
/// <summary> /// Clones the current Board. /// </summary> /// <returns>A copy of the current Board.</returns> public Board Clone() { Board cloned = (Board)this.MemberwiseClone(); cloned.cells = (byte[, ])cells.Clone(); return(cloned); }
public void InitializePathFindingVariables(byte[] rawMapData, int bytesPerRow, long cols, long rows) { processedFullSizeMapDataForPathFinding = new byte[cols * Terrain.MapCellSizeI, rows *Terrain.MapCellSizeI]; Terrain.PopulatePathfindingGrid(rawMapData, bytesPerRow, cols, rows, processedFullSizeMapDataForPathFinding); processedFullSizeMapDataForExploration = processedFullSizeMapDataForPathFinding.Clone() as byte[, ]; IdIslands(rawMapData, bytesPerRow, cols, rows); }
private void FrmRaw_Load(object sender, EventArgs e) { // 이미지 불러오기 using (OpenFileDialog dialog = new OpenFileDialog()) { dialog.InitialDirectory = @"C:\Temp\Pet_RAW"; dialog.Filter = "Raw Image|*.raw;"; if (dialog.ShowDialog() == DialogResult.OK) { // 가로세로 계산 _width = _height = (int)Math.Sqrt((double)(new FileInfo(dialog.FileName)).Length); _inImage = new byte[_height, _width]; // 이미지를 읽어서 배열에 저장 using (BinaryReader br = new BinaryReader(new FileStream(dialog.FileName, FileMode.Open))) { for (int i = 0; i < _height; i++) { for (int k = 0; k < _width; k++) { _inImage[k, i] = br.ReadByte(); } } } // 화면에 출력 _outImage = (byte[, ])_inImage.Clone(); Display(_width, _height); } } }
static byte[,] evolve(byte[,] data) { int w = data.GetLength(0), h = data.GetLength(1); byte[,] field = (byte[, ])data.Clone(); byte friendly_neighborhood = 0; for (int i = 0; i < w; i++) { for (int j = 0; j < h; j++) { friendly_neighborhood = (byte)(data[next(i - 1, w), next(j - 1, h)] + data[i, next(j - 1, h)] + data[next(i + 1, w), next(j - 1, h)] + data[next(i - 1, w), j] + data[next(i + 1, w), j] + data[next(i - 1, w), next(j + 1, h)] + data[i, next(j + 1, h)] + data[next(i + 1, w), next(j + 1, h)]); if (data[i, j] == 1) { field[i, j] = (byte)((friendly_neighborhood == 2 || friendly_neighborhood == 3) ? 1 : 0); } else { field[i, j] = (byte)((friendly_neighborhood == 3) ? 1 : 0); } } } return(field); }
public List lineList; //list of lines public Coloumn(int inpWidth, int inpHeight, byte[,] input) { // // TODO: Add constructor logic here // this.lineList = new List(); this.height = inpHeight; this.width = inpWidth; //array = new byte[height, width]; this.array = (byte[, ])input.Clone(); colImage = new Bitmap(width, height); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { if (this.array[y, x] == 0) { colImage.SetPixel(x, y, System.Drawing.Color.Black); } else { colImage.SetPixel(x, y, System.Drawing.Color.Red); } } //for } //for } //cunstructor
public static Tuple <int, int> GetMaxScoreMove(byte[,] board, byte tile) { // A much more naive version of AI compared to GetAIMove or MinimaxAlphaBeta. // This function just selects the move with highest score. // This is the "easy" AI mode. List <Tuple <int, int> > validMoves = GetValidMoves(board, tile); if (validMoves.Count > 0) { int bestScore = int.MinValue; Tuple <int, int> bestMove = validMoves[0]; foreach (Tuple <int, int> move in validMoves) { byte[,] childBoard = board.Clone() as byte[, ]; MakeMove(childBoard, move, tile); int nodeScore = GetScore(board, tile) * rng.Next(-5, 5); if (nodeScore > bestScore) { bestScore = nodeScore; bestMove = move; } } return(bestMove); } return(null); }
public static byte[,] dilation(byte[,] slika) { int w = slika.GetLength(1); int h = slika.GetLength(0); byte[,] retVal = (byte[, ])slika.Clone(); int[] ii = { 0, 1, 1, 1, 0, -1, -1, -1 }; int[] jj = { 1, 1, 0, -1, -1, -1, 0, 1 }; int n = ii.Length; for (int y = 1; y < h - 1; y++) { for (int x = 1; x < w - 1; x++) { Boolean b = false; for (int t = 0; t < n; t++) { if (slika[y + ii[t], x + jj[t]] == 0) // BAR JEDNA CRNA TACKA { b = true; break; } } if (b == true) { retVal[y, x] = 0; } else { retVal[y, x] = 255; } } } return(retVal); }
public void initialize(int inpHeight, int inpWidth, int inpBaseLine, byte [,] input) { this.height = inpHeight; this.width = inpWidth; this.baseLine = inpBaseLine; this.ligatureLsit = new List(); this.D_templates = new List(); this.diacritics = new List(); array = (byte[, ])input.Clone(); lineImage = new Bitmap(this.width, this.height); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { if (this.array[y, x] == 0) { lineImage.SetPixel(x, y, System.Drawing.Color.Black); } else { lineImage.SetPixel(x, y, System.Drawing.Color.Red); } } //for } //for }
/// <summary> /// Clone the glyph. /// </summary> /// /// <returns>Returns clone of the glyph.</returns> /// /// <remarks><para><note>It is user's responsibility to clone <see cref="UserData"/> property if it is /// set to reference type object.</note></para></remarks> /// public object Clone( ) { Glyph clone = new Glyph(name, (byte[, ])data.Clone( )); clone.userData = userData; return(clone); }
public void ComparesArraysCorrectly() { byte[,] array1 = { { 1, 2 }, { 2, 3 }, { 4, 5 } }; byte[,] array2 = array1.Clone() as byte[, ]; bool equal = ByteExtension.AreEqual(array1, array2); Assert.IsTrue(equal); }
public void finalizeAssemblerFuncSharp(byte[,] resultArray) { this.preBitmap = curBitmap; this.pixelArray = (byte[, ])resultArray.Clone(); Bitmap bmp = createBitmapFromPixelArray(this.pixelArray, this.bitmapInfo.SizeX, this.bitmapInfo.SizeY); this.curBitmap = convertTo24bpp(bmp); }
/// <summary> /// Метод возвращает сгенерированную конфигурацию /// </summary> /// <returns></returns> public byte[,] gen() { if (trigger0) { return((byte[, ])Cells.Clone()); } return(null); }
public byte[,] Solve(byte[,] input, int[][] xClues, int[][] yClues) //0=white, 1=black { int xDimension = input.GetLength(0); int yDimension = input.GetLength(1); if (xClues.Length != xDimension) { throw new ArgumentException("Wrong number of X clues"); } if (yClues.Length != yDimension) { throw new ArgumentException("Wrong number of Y clues"); } //Generate possibilities List <List <byte[]> > xPossibilities = Possibilities(xClues, yDimension); List <List <byte[]> > yPossibilities = Possibilities(yClues, xDimension); var output = (byte[, ])input.Clone(); for (int i = 0; i < xDimension; i++) { for (int j = 0; j < yDimension; j++) { if (output[i, j] == 0) { output[i, j] = 2; //2 = unknown } } } bool[] xSolved = new bool[xDimension]; bool[] ySolved = new bool[yDimension]; //Loop while (xSolved.Contains(false) || ySolved.Contains(false)) { //For each column for (int i = 0; i < xDimension; i++) { var column = GetColumn(output, i); (var result, bool solved) = Prune(column, xPossibilities[i]); xSolved[i] = solved; InsertColumn(output, result, i); } //For each row for (int j = 0; j < yDimension; j++) { var row = GetRow(output, j); (var result, bool solved) = Prune(row, yPossibilities[j]); ySolved[j] = solved; InsertRow(output, result, j); } } return(output); }
//*******************************CLASS METHODS*************************************/ //create a shape class using byte array passed in as arguments (also finds rotations) public Shape(byte[,] map, System.Drawing.Color c1, System.Drawing.Color c2) { rotations = new List <byte[, ]>(); rotations.Add((byte[, ])map.Clone()); findAllRotations(); MaxHeight = map.GetLength(0) > map.GetLength(1) ? map.GetLength(0) : map.GetLength(1); this.c1 = c1; this.c2 = c2; }
public static byte[,] Copy(byte[,] board) { if (board == null) { throw new ArgumentNullException(nameof(board)); } byte[,] n = board.Clone() as byte[, ]; return(n); }
/// <summary> /// Загрузка формы /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Form1_Load(object sender, EventArgs e) { step = new CA_Step(CellAutomaton.CellularAutomaton); glControl1.Size = new Size(n * (squareDim + 1), hScrollBar1.Location.Y - glControl1.Location.Y); //617 is magic number | n * (squareDim + 1) cameraChanged(); //Фон // panel1.BackColor = Color.Black; //Заполняем матрицу CellAutomaton.FillMatrix(Cells); memarr = (byte[, ])Cells.Clone(); //Генерация поколений выключена GenerationTimer.Enabled = false; //Конвеевская жизнь по умолчанию. S/B 23/3 rulesChListBox.SetItemChecked(2, true); rulesChListBox.SetItemChecked(3, true); rulesChListBox.SetItemChecked(12, true); //Правила GetArrayOfRules(); ToolStrip_timebtn.Text = DELAY + GenerationTimer.Interval; cellC = Color.FromArgb(0, 255, 0); //Зеленый цвет backC = Color.Black; hScrollBar1.Width = glControl1.Width; vScrollBar1.Height = glControl1.Height; ScrollBarsInitialize(); thorChB.Checked = true; toolStripLabel_steps.Text = "Число шагов: " + 0; toolStripLabel_X.Text = "X: " + 0; toolStripLabel_Y.Text = "Y: " + 0; FullSize(); }
public StructureTemplate(byte[,] map, string id) { Id = id; if (map is null) { throw new ArgumentNullException(nameof(map)); } StructureMap = (byte[, ])map.Clone(); }
/// <summary> /// Create a new wall grid out of a 2d array of 0s and 1s. /// </summary> /// <param name="walls">Must contain 0s corresponding to floors and 1s corresponding to walls.</param> /// <param name="position">Location in world coordinates of coordinate (0,0) in the walls array. Mainly used to ensure /// chunks line up if breaking a grid into multiple pieces.</param> public WallGrid(byte[,] walls, Vector3 position, int scale = 1) { ValidateWalls(walls); Position = position; Scale = scale; Length = walls.GetLength(0); Width = walls.GetLength(1); this.walls = (byte[, ])walls.Clone(); }
public ImageData Clone() { ImageData cb = new ImageData(); cb.A = (byte[, ])_alpha.Clone(); cb.B = (byte[, ])_blue.Clone(); cb.G = (byte[, ])_green.Clone(); cb.R = (byte[, ])_red.Clone(); return(cb); }
/// <summary> /// Instanciate a new key. /// </summary> /// <param name="isPrivate">Defines whether or not this key is private.</param> /// <param name="fragments">Matrix containing the fragments of the key.</param> /// <param name="size">Size of the key.</param> public Key(bool isPrivate, byte[,] fragments, int size = 4) { if (fragments.GetLength(0) + fragments.GetLength(1) != size) { throw new ArgumentException("Given array does not match the given size.", "fragments"); } this.IsPrivate = isPrivate; this.Version = (Version)size; this.Fragments = fragments.Clone() as byte[, ]; }
/// <summary> /// Initializes a new instance of the <see cref="DoubleArrayChromosome"/> class. /// </summary> /// /// <param name="chromosomeGenerator">Chromosome generator - random number generator, which is /// used to initialize chromosome's genes, which is done by calling <see cref="Generate"/> method /// or in class constructor.</param> /// <param name="mutationMultiplierGenerator">Mutation multiplier generator - random number /// generator, which is used to generate random multiplier values, which are used to /// multiply chromosome's genes during mutation.</param> /// <param name="mutationAdditionGenerator">Mutation addition generator - random number /// generator, which is used to generate random addition values, which are used to /// add to chromosome's genes during mutation.</param> /// <param name="values">Values used to initialize the chromosome.</param> /// /// <remarks><para>The constructor initializes the new chromosome with specified <paramref name="values">values</paramref>. /// </para></remarks> /// /// <exception cref="ArgumentOutOfRangeException">Invalid length of values array.</exception> /// public MusicChromosome(byte[,] values, int tracks, int length) { // save parameters this.chromosomeGenerator = new AForge.Math.Random.StandardGenerator( ); this.mutationMultiplierGenerator = new AForge.Math.Random.StandardGenerator(); this.mutationAdditionGenerator = new AForge.Math.Random.StandardGenerator(); this.length = length; this.tracks = tracks; // copy specified values val = (byte[, ])values.Clone(); }
public static Tuple <int, int> GetAIMove(byte[,] board, int depth, byte tile) { // The "convienence" function that allows us to use our AI algorithm. List <Tuple <int, int> > validMoves = GetValidMoves(board, tile); validMoves = validMoves.OrderBy(a => rng.Next(-10, 10)).ToList(); if (validMoves.Count > 0) { int bestScore; if (tile == Black) { bestScore = int.MinValue; } else if (tile == White) { bestScore = int.MaxValue; } else { return(null); } Tuple <int, int> bestMove = validMoves[0]; if (GetScore(board, Black) + GetScore(board, White) > 55) { depth = 100; } foreach (Tuple <int, int> move in validMoves) { byte[,] childBoard = board.Clone() as byte[, ]; MakeMove(childBoard, move, tile); int nodeScore; if (tile == Black) { nodeScore = MinimaxAlphaBeta(childBoard, depth - 1, int.MinValue, int.MaxValue, OtherTile(tile), false); if (nodeScore > bestScore) { bestScore = nodeScore; bestMove = move; } } else { nodeScore = MinimaxAlphaBeta(childBoard, depth - 1, int.MinValue, int.MaxValue, OtherTile(tile), true); if (nodeScore < bestScore) { bestScore = nodeScore; bestMove = move; } } } return(bestMove); } return(null); }
public static byte[,] MergeFields(byte[,] TargetField, byte[,] Merger) { byte[,] NewVoxels = (byte[, ])TargetField.Clone(); for (int i = 0; i < TargetField.GetLength(0) && i < Merger.GetLength(0); i++) { for (int j = 0; j < TargetField.GetLength(1) && j < Merger.GetLength(1); j++) { NewVoxels[i, j] = Merger[i, j]; } } return(NewVoxels); }
// Use this for initialization void Start() { //Setup Texture m_Texture = new Texture2D(m_Widht, m_Height); m_Texture.name = "GameOfLifeTexture"; m_Texture.filterMode = FilterMode.Point; m_Old = new byte[m_Widht, m_Height]; m_Update = (byte[, ])m_Old.Clone(); GenerateRandomGrid(); }
public DuyetDiemAnhChu(byte[,] arr, Bitmap bitmap) { this.bitmap = bitmap; var phanNguong = new HandleThreshold(128); phanNguong.ConvertImage(arr); this.Arr = arr.Clone() as byte[, ]; arrr = arr; ChieuAnhSangTayPhai(); TimToaDoHinhChieu(); }
public static int MinimaxAlphaBeta(byte[,] board, int depth, int a, int b, byte tile, bool isMaxPlayer) { // The heart of our AI. Minimax algorithm with alpha-beta pruning to speed up computation. // Higher search depths = greater difficulty. if (depth == 0 || GetWinner(board) != Empty) { return(Evaluation(board)); } int bestScore; if (isMaxPlayer) { bestScore = int.MinValue; } else { bestScore = int.MaxValue; } List <Tuple <int, int> > validMoves = GetValidMoves(board, tile); if (validMoves.Count > 0) { foreach (Tuple <int, int> move in validMoves) { byte[,] childBoard = board.Clone() as byte[, ]; MakeMove(childBoard, move, tile); int nodeScore = MinimaxAlphaBeta(childBoard, depth - 1, a, b, OtherTile(tile), !isMaxPlayer); if (isMaxPlayer) { bestScore = Math.Max(bestScore, nodeScore); a = Math.Max(bestScore, a); } else { bestScore = Math.Min(bestScore, nodeScore); b = Math.Min(bestScore, b); } if (b <= a) { break; } } } else { return(MinimaxAlphaBeta(board, depth, a, b, OtherTile(tile), !isMaxPlayer)); } return(bestScore); }