public static void Starter()//Generates first and/or additional yards.
{
if (yards.Count == 0)
{
cash = 0;
crypto = 0;
YardPrestigeList.Add(0);
//starts the default game and the first turret
yards.Add(defaultstart);
Int64[,] currentyard = yards[0];
currentyard[0, 1] = turrets[0, 0];
currentyard[0, 2] = turrets[0, 1];
currentyard[0, 3] = turrets[0, 2];
yards[0] = currentyard;
}
else
{
YardPrestigeList.Add(0);
//starts all of the yards from this point on when unlocked
yards.Add(defaultstart);
Int64[,] currentyard = yards[yards.Count];
currentyard[0, 1] = yards.Count * turrets[0, 0];
currentyard[0, 2] = yards.Count * turrets[0, 1];
currentyard[0, 3] = yards.Count * turrets[0, 2];
yards[yards.Count] = currentyard;
}
}
}; //The Prestige of each individual yard.
public static void LoadSaveTurrets(string SaveDataString)
{
bool catchFound = false;
string[] subOfSaveTurrets = SaveDataString.Split('|');
for (int i = 0; i > subOfSaveTurrets.Length; i++)
{
if (subOfSaveTurrets[i] != " ")
{
if (catchFound == false)
{
Int64[,] tempArr = defaultstart;
string[] _subset = subOfSaveTurrets[i].Split('=');
yards.Add(defaultstart);
for (int x = 0; x < _subset.Length; x++)
{
string[] tempSub = _subset[x].Split('-');
for (int y = 0; y < tempSub.Length; y++)
{
yards[i][x, y] = Convert.ToInt32(tempSub[y]);
}
}
}
else
{
//-----------------------------------------------------------------------FUTURE SAVE DATA-----------------------------------------------------------------------------------------------------
}
}
else
{
catchFound = true;
}
}
HandleTurretLoad();
}
public static string SaveSenderTurrets()
{
//int temp = yards.Count;
string Save = "";
for (int i = 0; i < yards.Count; i++)
{
Int64[,] tempArr = yards[i];
for (int j = 0; j < 50; j++)
{
Save += Convert.ToString(tempArr[j, 0]);
Save += "-";
Save += Convert.ToString(tempArr[j, 1]);
Save += "-";
Save += Convert.ToString(tempArr[j, 2]);
Save += "=";
}
Save += "|";
Debug.Log(("" + Save));
}
for (int i = 0; i < YardPrestigeList.Count; i++)
{
Save += Convert.ToString(YardPrestigeList[i]);
if ((i + 1) < YardPrestigeList.Count)
{
Save += ",";
}
}
//Save += Convert.ToString(YardPrestigeList);
return(Save);
}
public Int64 Evaluate(Int64[,] board)
{
const Int64 numberOfRows = 7;
const Int64 kingBonusPoints = 3;
Int64 player1Counter = 0;
Int64 player2Counter = 0;
for (int i = 0; i < board.GetLength(0); i++)
{
for (int j = 1 - (i % 2); j < board.GetLength(1); j++)
{
Int64 piece = board[i, j];
if (piece == 1)
{
player1Counter += 5 + (numberOfRows - i);
}
else if (piece == 2)
{
player2Counter += 5 + i;
}
else if (piece == 3)
{
player1Counter += 5 + numberOfRows + kingBonusPoints;
}
else if (piece == 4)
{
player2Counter += 5 + numberOfRows + kingBonusPoints;
}
}
}
return(player2Counter - player1Counter);
}
public Int64 Evaluate(Int64[,] board)
{
Int64 player1Counter = 0;
Int64 player2Counter = 0;
for (Int64 row = 0; row < board.GetLength(0); row++)
{
for (Int64 column = 1 - (row % 2); column < board.GetLength(1); column++)
{
if (board[row, column] == 1)
{
player1Counter++;
}
else if (board[row, column] == 2)
{
player2Counter++;
}
else if (board[row, column] == 3)
{
player1Counter += 2;
}
else if (board[row, column] == 4)
{
player2Counter += 2;
}
}
}
return(player2Counter - player1Counter);
}
/// <summary>
/// Rotate the matrix into its final position. The perimeter of progressively smaller bounding rectangles
/// are each rotated the minimum number of rotations to achive the result (we only need to rotate a given
/// rectangle up to one full rotation). We stop rotating once we've finished with the inner-most (smallest)
/// bounding rectangle, whereby one of its dimensions will be of size 2.
/// </summary>
/// <param name="rows">The number of rows in the matrix</param>
/// <param name="cols">The number of columns in the matrix</param>
/// <param name="rotations">The number of rotations to execute</param>
/// <param name="matrix">The matrix to rotate</param>
/// <returns>The rotated matrix</returns>
public Int64[,] GetRotatedMatrix(Int64 rows, Int64 cols, Int64 rotations, Int64[,] matrix)
{
Int64 minX = 0;
Int64 maxX = cols;
Int64 minY = 0;
Int64 maxY = rows;
Int64 adjustedRotations = rotations;
while (AtLeastOneDimensionIsGreaterThanOne(minX, maxX, minY, maxY))
{
Int64 fullRotation = GetBoundingRectanglePerimeter(minX, maxX, minY, maxY);
// we only need to bother with up to one full rotation
if (rotations > fullRotation)
{
adjustedRotations = rotations % fullRotation;
}
// rotate the bounding rectangle for each adjusted rotation
for (Int64 rotationIndex = 0; rotationIndex < adjustedRotations; rotationIndex++)
{
RotateMatrixBoundingRectangle(minX, maxX, minY, maxY, ref matrix);
}
// move down a row and across a column
minX++;
maxX--;
minY++;
maxY--;
}
return(matrix);
}
public Material[] YdnMatTypeMat(Item[] items)
{
Material[] typeId = new Material[items.Length - 1];
for (int i = 0; i < items.Length - 1; ++i)
{
typeId[i] = new Material();
}
int r = 0;
foreach (var item in items)
{
Int64[,] materials = item.getProdMats();
for (int i = 0; i < (materials.Length / 2) - 1; ++i)
{
//find valid material
if (materials[i, 1] != 0)
{
//check if the material has already been listed
bool found = false;
for (int j = 0; j < typeId.Length; ++j)
{
if (materials[i, 1] == typeId[j].ID)
{
//item already exists
found = true;
break;
}
}
//check the material isn't an item
foreach (var thing in items)
{
if (thing.getTypeID() == materials[i, 1])
{
found = true;
break;
}
}
//add item to the material list
if (found == false)
{
typeId[r].ID = Convert.ToInt32(materials[i, 1]);
++r;
}
}
}
}
//remove null values
Material[] temp = new Material[r];
for (int i = 0; i < r; ++i)
{
temp[i] = typeId[i];
}
typeId = new Material[r];
typeId = temp;
return(typeId);
}
public static Boolean CheckMoveUpLeft(Int64[,] board, Int64 height, Int64 width)
{
try
{
return(board[height - 1, width - 1] == 5 || board[height - 1, width - 1] == 6);
}
catch { return(false); }
}
public static Boolean CheckMoveDownRight(Int64[,] board, Int64 height, Int64 width)
{
try
{
return(board[height + 1, width + 1] == 5 || board[height + 1, width + 1] == 6);
}
catch { return(false); }
}
public static List <Int64> HandLeNewTurret(int yard, int location) //takes the yard that you are building a turret and places a level one
{
Int64[,] currentyard = yards[yard];
currentyard[location, 0] = 1;
//add currency drop =
yards[yard] = currentyard;
HandleTurretLoad();
return(TurretStats(yard, location));
}
/// <summary>
/// Print the matrix out to the console
/// </summary>
/// <param name="rows">The number of rows in the matrix</param>
/// <param name="cols">The number of columns in the matrix</param>
/// <param name="matrix">The matrix to print</param>
public void PrintMatrix(Int64 rows, Int64 cols, Int64[,] matrix)
{
for (Int64 rowIndex = 0; rowIndex < rows; rowIndex++)
{
for (Int64 colIndex = 0; colIndex < cols; colIndex++)
{
Console.Write(matrix[colIndex, rowIndex] + (colIndex == (cols - 1) ? "\n" : " "));
}
}
}
public static List <Int64> TurretStats(int yard, int location) //call this to assign stats to a turret on turret awake.
{
Int64[,] currentyard = yards[yard];
List <Int64> templist = new List <Int64>();
templist.Add(currentyard[location, 0]);
templist.Add(currentyard[location, 1]);
templist.Add(currentyard[location, 2]);
templist.Add(currentyard[location, 3]);
return(templist);
}
static void PanelPaint(int robot_x, int robot_y, Int64 output, Int64[,] path)
{
if (output == 0)
{
path[robot_x, robot_y] = 0;
}
else if (output == 1)
{
path[robot_x, robot_y] = 1;
}
}
public MinimaxOutcome minimax(Int64[,] board, Int64 depth, Boolean minOrMax)
{
if (depth == 0)
{
return(new MinimaxOutcome
{
Evaluation = Evaluate(board)
});
}
if (minOrMax)
{
Int64 maxEval = -1000;
PotentialNextMove bestMove = null;
List <PotentialNextMove> player2MovesBoards = GetAvailableBoards(board, 2);
foreach (PotentialNextMove player2MovesBoard in player2MovesBoards)
{
MinimaxOutcome evaluation = minimax(player2MovesBoard.Board, depth - 1, false);
maxEval = Math.Max(maxEval, evaluation.Evaluation);
if (maxEval == evaluation.Evaluation)
{
bestMove = player2MovesBoard;
}
}
return(new MinimaxOutcome
{
PotentialNextMove = bestMove,
Evaluation = maxEval
});
}
else
{
Int64 minEval = 1000;
PotentialNextMove bestMove = null;
List <PotentialNextMove> player1MovesBoards = GetAvailableBoards(board, 1);
foreach (PotentialNextMove player1MovesBoard in player1MovesBoards)
{
MinimaxOutcome evaluation = minimax(player1MovesBoard.Board, depth - 1, true);
minEval = Math.Min(minEval, evaluation.Evaluation);
if (minEval == evaluation.Evaluation)
{
bestMove = player1MovesBoard;
}
}
return(new MinimaxOutcome
{
PotentialNextMove = bestMove,
Evaluation = minEval
});
}
}
public void Solve()
{
Int64[] dimensions = Console.ReadLine().Split(' ').Select(Int64.Parse).ToArray <Int64>();
Int64 rows = dimensions[0];
Int64 cols = dimensions[1];
Int64 rotations = dimensions[2];
Int64[,] matrix = GetMatrix(rows, cols);
matrix = GetRotatedMatrix(rows, cols, rotations, matrix);
PrintMatrix(rows, cols, matrix);
}
static Int64 SetDiffs(List <Int64> Taken, List <Int64> Remains, Int64[,] diffs)
{
Int64 res = 0;
foreach (var t in Taken)
{
foreach (var r in Remains)
{
res += diffs[t, r];
}
}
return(res);
}
public static void Main(string[] args)
{
//StreamReader sr = new StreamReader(args[0]);
//StreamWriter sw = new StreamWriter(args[1]);
StreamReader sr = new StreamReader("input.txt");
StreamWriter sw = new StreamWriter("output.txt");
Int64 m_nCase = Convert.ToInt64(sr.ReadLine());
String[] tmpA;
String tmp;
for (Int64 cs = 1; cs <= m_nCase; cs++)
{
tmpA = sr.ReadLine().Split(' ');
Int64 m_M = Convert.ToInt64(tmpA[0]);
Int64 m_V = Convert.ToInt64(tmpA[1]);
m_nNodeR = (m_M - 1) / 2;
m_nNodeL = (m_M + 1) / 2;
m_nodeType = new Int64[2, m_M + 1];
m_memoiz = new Int64[2, m_M + 1];
for (Int64 i = 1; i <= m_nNodeR; i++)
{
tmpA = sr.ReadLine().Split(' ');
m_nodeType[0, i] = Convert.ToInt64(tmpA[0]);
m_nodeType[1, i] = Convert.ToInt64(tmpA[1]);
m_memoiz[0, i] = -2;
m_memoiz[1, i] = -2;
}
for (Int64 i = m_nNodeR + 1; i <= m_M; i++)
{
m_nodeType[0, i] = Convert.ToInt64(sr.ReadLine());
m_memoiz[0, i] = -2;
m_memoiz[1, i] = -2;
}
Int64 ret = FindNum(1, m_V);
if (ret < 0)
{
sw.Write(String.Format("Case #{0:G}: IMPOSSIBLE\n", cs));
}
else
{
sw.Write(String.Format("Case #{0:G}: {1:G}\n", cs, ret));
}
}
sr.Close();
sw.Close();
}
public List <PotentialNextMove> GetAvailableBoards(Int64[,] board, Int64 player)
{
List <PotentialNextMove> results = new List <PotentialNextMove>();
List <NextMove> moves = FindMove.FindAvailableMoves(board, player);
foreach (NextMove move in moves)
{
//Copy board
Int64[,] moveBoard = (Int64[, ])board.Clone();
//Remove taken pieces form the board
if (move.Takes.Count > 0)
{
foreach (Piece take in move.Takes)
{
moveBoard[take.Height, take.Width] = 5;
}
}
//Add kings
if (player == 1 && move.NextHeight == 0)
{
moveBoard[move.CurrentHeight, move.CurrentWidth] = 5;
moveBoard[move.NextHeight, move.NextWidth] = 3;
}
else if (player == 2 && move.NextHeight == 7)
{
moveBoard[move.CurrentHeight, move.CurrentWidth] = 5;
moveBoard[move.NextHeight, move.NextWidth] = 4;
}
else
{
Int64 tempValue = moveBoard[move.CurrentHeight, move.CurrentWidth];
moveBoard[move.CurrentHeight, move.CurrentWidth] = 5;
moveBoard[move.NextHeight, move.NextWidth] = tempValue;
}
results.Add(new PotentialNextMove
{
Board = moveBoard,
CurrentHeight = move.CurrentHeight,
CurrentWidth = move.CurrentWidth,
NextHeight = move.NextHeight,
NextWidth = move.NextWidth,
Takes = move.Takes
});
}
return(results);
}
public void WriteExtended(string key, Int64[,] array2D)
{
if (writer == null)
{
throw new FileEE("無効なストリームです");
}
if (array2D == null)
{
throw new FileEE("無効な配列が渡されました");
}
int countX = 0;
int length0 = array2D.GetLength(0);
int length1 = array2D.GetLength(1);
int[] countY = new int[length0];
for (int x = 0; x < length0; x++)
{
for (int y = 0; y < length1; y++)
{
if (array2D[x, y] != 0)
{
countX = x + 1;
countY[x] = y + 1;
}
}
}
if (countX == 0)
{
return;
}
writer.WriteLine(key);
for (int x = 0; x < countX; x++)
{
if (countY[x] == 0)
{
writer.WriteLine("");
continue;
}
StringBuilder builder = new StringBuilder("");
for (int y = 0; y < countY[x]; y++)
{
builder.Append(array2D[x, y].ToString());
if (y != countY[x] - 1)
{
builder.Append(",");
}
}
writer.WriteLine(builder.ToString());
}
writer.WriteLine(FINISHER);
}
public void setValueAll2D(int varInt, Int64 value)
{
Int64[,] array = dataIntegerArray2D[varInt];
int a1 = array.GetLength(0);
int a2 = array.GetLength(1);
for (int i = 0; i < a1; i++)
{
for (int j = 0; j < a2; j++)
{
array[i, j] = value;
}
}
}
public static void HandleLevelUP(int yard, int location)//levelup a turret
{
Int64[,] currentyard = yards[yard];
Int64 level = currentyard[location, 0];
Int64 CTU = currentyard[location, 3];
//add currency drop -=CTU
level += 1;
currentyard[location, 0] = level;
currentyard[location, 1] = turrets[level, 0];
currentyard[location, 2] = turrets[level, 1];
currentyard[location, 3] = turrets[level, 2];
yards[yard] = currentyard;
}
public void setProdMats(int[,] mats)
{
prodMats = new Int64[mats.Length / 2, 2];
//move values from one array to another
for (int i = 0; i < (mats.Length / 2); ++i)
{
if (mats[i, 1] != 0)
{
prodMats[i, 0] = mats[i, 0];
prodMats[i, 1] = mats[i, 1];
}
}
}
static int GetRobotInput(int robot_x, int robot_y, Int64[,] path)
{
if (path[robot_x, robot_y] == 2 || path[robot_x, robot_y] == 0)
{
return(0);
}
if (path[robot_x, robot_y] == 1)
{
return(1);
}
else
{
return(666);
}
}
public void CanConstructTensorVariableView()
{
Device device = new Device(testContext);
Compiler.PlaidML.Shape s1 = new Compiler.PlaidML.Shape(testContext, PlaidmlDatatype.PLAIDML_DATA_FLOAT64, 2, 3);
DeviceTensor t = new DeviceTensor(device, s1, "t");
DeviceTensorView <Int64> v = t.CreateView <Int64>(MemoryMapType.Discard);
Int64[,] array = { { 0, 1, 3 }, { 4, 5, 6 } };
v.CopyFromAndFree(array.Flatten <Int64>().ToArray());
Assert.Throws <InvalidOperationException>(() => v.Free());
DeviceTensorView <Int64> v2 = t.CreateView <long>(MemoryMapType.Retain);
Assert.Equal(3, v2[2]);
Assert.Equal(6, v2[5]);
}
private void writeData(Int64[,] array)
{
int countZero = 0; //0については0が連続する数を記憶する。その他はそのまま記憶する。
int countAllZero = 0; //列の要素が全て0である列の連続する数を記憶する。列の要素に一つでも非0があるなら通常の記憶方式。
int length0 = array.GetLength(0);
int length1 = array.GetLength(1);
writer.Write(length0);
writer.Write(length1);
for (int x = 0; x < length0; x++)
{
for (int y = 0; y < length1; y++)
{
if (array[x, y] == 0)
{
countZero++;
}
else
{
if (countAllZero > 0)
{
writer.Write(Ebdb.ZeroA1);
this.m_WriteInt(countAllZero);
countAllZero = 0;
}
if (countZero > 0)
{
writer.Write(Ebdb.Zero);
this.m_WriteInt(countZero);
countZero = 0;
}
this.m_WriteInt(array[x, y]);
}
}
if (countZero == length1) //列の要素が全部0
{
countAllZero++;
}
else
{
writer.Write(Ebdb.EoA1); //非0があるなら列終端記号を記憶
}
countZero = 0;
}
writer.Write(Ebdb.EoD);
}
private static void CalculateGS(byte[,] src, int [,] G, Int64[,] S, int w, int h, ProgressBar p1)
{
MainForm.UpdateLabel("Calculating integral images");
G[0, 0] = src[0, 0];
S[0, 0] = src[0, 0] * src[0, 0];
byte pvalue = 0;
p1.Value = 0;
p1.Minimum = 0;
p1.Maximum = w / 10;
for (int i = 0; i < w; i++)//i-the number of COLUMN,i.e X
{
for (int j = 0; j < h; j++)
{
if (i == 0)
{
if (j == 0)
{
continue;
}
G[i, j] = G[i, j - 1] + src[i, j];
S[i, j] = S[i, j - 1] + (int)src[i, j] * src[i, j];
}
else if (j == 0)
{
if (i == 0)
{
continue;
}
G[i, j] = G[i - 1, j] + src[i, j];
S[i, j] = S[i - 1, j] + (int)src[i, j] * src[i, j];
}
else
{
G[i, j] = G[i - 1, j] + G[i, j - 1] - G[i - 1, j - 1] + src[i, j];
S[i, j] = S[i - 1, j] + S[i, j - 1] - S[i - 1, j - 1] + (int)src[i, j] * src[i, j];
}
}
pvalue++;
if (pvalue == 10)
{
pvalue = 0;
p1.Value++;
}
}
}
private static void InitialiseZobristValues()
{
// Generate some random values
Random random = new Random();
zobristRandomPositionValues = new Int64[FIELD_SIZE * FIELD_SIZE, 6];
for (int i = 0; i < zobristRandomPositionValues.GetLength(0); i++)
{
for (int j = 0; j < zobristRandomPositionValues.GetLength(1); j++)
{
zobristRandomPositionValues[i, j] = GenerateRandomLong(random);
}
}
zobristRandomPlayerValues = new Int64[2];
zobristRandomPlayerValues[(int)Game.Player.White] = GenerateRandomLong(random);
zobristRandomPlayerValues[(int)Game.Player.Red] = GenerateRandomLong(random);
}
public override void Run()
{
Int64[,] enrolled = { { 1091150, 18, 20 },
{ 1091250, 11, 20 },
{ 1091270, 9, 25 },
{ 1091300, 4, 20 },
{ 1091350, 20, 20 } };
for (int i = 0; i <= enrolled.GetUpperBound(0); i++)
{
Console.ForegroundColor = ConsoleColor.DarkYellow;
Console.WriteLine("Course " + enrolled[i, 0]);
Console.ResetColor();
Console.WriteLine("Seats available = {0}\n" +
"---------------------",
enrolled[i, 2] - enrolled[i, 1]);
}
}
static void PrintRegistration(Int64[,] path)
{
for (int i = 20; i < path.GetLength(0) - 10; i++)
{
for (int j = 10; j < path.GetLength(1); j++)
{
if (path[i, j] == 1)
{
Console.Write("{0}", path[i, j]);
}
else
{
Console.Write(" ");
}
}
Console.WriteLine();
}
}
public static Tree CheckTakeUp(Int64[,] board, Int64 i, Int64 j, Int64[] playerToTake, Tree tree)
{
try
{
//left
if (Array.IndexOf(playerToTake, board[i - 1, j - 1]) > -1)
{
if (board[i - 2, j - 2] == 5 || board[i - 2, j - 2] == 6)
{
tree.Left = new Tree(new TreeTake
{
TakeHeight = i - 1,
TakeWidth = j - 1,
CurrentHeight = i - 2,
CurrentWidth = j - 2
});
CheckTakeUp(board, i - 2, j - 2, playerToTake, tree.Left);
}
}
}
catch { }
try
{
//Right
if (Array.IndexOf(playerToTake, board[i - 1, j + 1]) > -1)
{
if (board[i - 2, j + 2] == 5 || board[i - 2, j + 2] == 6)
{
tree.Right = new Tree(new TreeTake
{
TakeHeight = i - 1,
TakeWidth = j + 1,
CurrentHeight = i - 2,
CurrentWidth = j + 2
});
CheckTakeUp(board, i - 2, j + 2, playerToTake, tree.Right);
}
}
}
catch { }
return(tree);
}
// Расшифровка
//-----------------------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------------
public static ZArrayDescriptor pi2_rshfr(ZArrayDescriptor[] img, int sN1, int sN2, int Diag, int pr_obr, int sdvg_x)
{
int w = img[0].width;
int h = img[0].height;
int NOD=China(sN1, sN2); // Проверка на взаимную простоту
// Вычисление формулы sN1, sN2 -> в глобальные n1, n2
// int[,] bmp_r = new int[sN2 + 3, sN1 + 3]; // Массив точек в таблице 2pi
// bmp_2pi(img, bmp_r, Diag, pr_obr, sdvg_x); // Заполнение массива bmp_r
Z = new Int64[w, h];
GLBL_FAZE(n1, n2, Diag); // Заполнение массива glbl_faze[] (Все -1 кроме номеров полос)
// glbl_faze1[] расширяется значениям номеров полос
// РАСШИФРОВКА (Заполнение Z[,])
rash_2pi(img[1], img[0], img[2], NOD, sdvg_x, n1, n2, Diag, Z);
ZArrayDescriptor result = new ZArrayDescriptor();
result.array = new long[w][];
for (int i = 0; i < w; i++)
{
result.array[i] = new long[h];
}
result.width = w;
result.height = h;
for (int i = 0; i < w; i++) // Отображение точек на pictureBox01
{
for (int j = 0; j < h; j++)
{
result.array[i][j] = Z[i, j];
}
}
//Z_bmp(result, Z); // Z -> bmp с масштабированием (bmp3 - маска)
return result;
}
public Int2DVariableToken(VariableCode varCode, VariableData varData)
: base(varCode, varData)
{
CanRestructure = false;
array = varData.DataIntegerArray2D[VarCodeInt];
}
public override void In()
{
if (array != null)
arrayList.Add(array);
//counter++;
array = new Int64[sizes[0], sizes[1]];
}
public override void Out()
{
//counter--;
//arrayList.RemoveAt(arrayList.Count - 1);
if (arrayList.Count > 0)
{
array = arrayList[arrayList.Count - 1];
arrayList.RemoveAt(arrayList.Count - 1);
}
else
array = null;
}
public StaticInt2DVariableToken(UserDefinedVariableData data)
: base(VariableCode.VAR2D, data)
{
CanRestructure = false;
int[] sizes = data.Lengths;
IsStatic = true;
array = new Int64[sizes[0], sizes[1]];
}
// Расшифровка
// --------------------------------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------------
public static Bitmap pi2_rshfr(Image[] img, int sN1, int sN2, int Diag, bool rd, bool SUB_rd, int pr_obr, int sdvg_x)
{
China(sN1, sN2); // Вычисление формулы sN1, sN2 -> в глобальные n1, n2
int[,] bmp_r = new int[sN2 + 3, sN1 + 3]; // Массив точек в таблице 2pi
int count = bmp_2pi(img, bmp_r, Diag, pr_obr, sdvg_x); // Заполнение массива bmp_r
int w = img[0].Width;
int h = img[0].Height;
Bitmap bmp1 = new Bitmap(img[1], w, h); // 1 фаза
Bitmap bmp2 = new Bitmap(img[0], w, h); // 2 фаза
Bitmap bmp3 = new Bitmap(img[2], w, h); // Маска
Bitmap bmp = new Bitmap( w, h); // Результат
Z = new Int64[w, h];
GLBL_FAZE(n1, n2, Diag); // Заполнение массива glbl_faze[] (Все -1 кроме номеров полос)
// для расшифровки glbl_faze1[] расширяется значениям номеров полос на допустимый диапазон
rash_2pi(bmp1, bmp2, bmp3, bmp_r, pr_obr, sdvg_x, sN1, sN2, Diag, Z); // РАСШИФРОВКА (Заполнение Z[,])
int x1 = 24, x2 = 460, y1 = 50;
//GraphClass1.grfk(w, h, x, y, Z);
Int64[] sub_line = new Int64[w];
if (SUB_rd) { Z_sub(x1, x2, y1, Z, w, h, sub_line); } //
//Z_sub1(x1, x2, y1, Z, w, h, bmp3, rd); // Вычитание плоскости
//GraphClass1.grfk(w, x, y, Z);
int x = 1075, y = 600;
Int64[] buf = new Int64[w]; for (int i = 0; i < w; i++) { buf[i] = Z[i, y]; } Graphic graphic = new Graphic(w, x, buf); graphic.Show(); // График по x
Int64[] buf1 = new Int64[h]; for (int i = 0; i < h; i++) { buf1[i] = Z[x, i]; } Graphic graphic1 = new Graphic(h, y, buf1); graphic1.Show(); // График по y
Z_bmp(bmp, bmp3, Z); // Z -> bmp с масштабированием (bmp3 - маска)
return bmp;
}
