public Surface(Proxys.SurfaceType surfacetype, Patch[,] patches, List <CatPoint> catPoints, SceneData scene, bool uLooped, bool vLooped)
{
SurfaceType = surfacetype;
this.patches = new List <Patch>();
this.uLooped = uLooped;
this.vLooped = vLooped;
foreach (var patch in patches)
{
this.patches.Add(patch);
patch.SetSurface(this);
}
this.catPoints = catPoints;
this.scene = scene;
PatchesU = patches.GetLength(1);
PatchesV = patches.GetLength(0);
this.catPoints.ForEach(x =>
{
x.OnReplace += OnPointReplaced;
x.DependentUnremovable += 1;
});
orderedPatches = patches;
ShowPoints = ShowPoints;
}
/// <summary>
/// Calculates the sum of the 3-digit numbers found in the top left corner of each sudoku solution grid
/// </summary>
static void P096()
{
int ans = 0;
List <int[, ]> sudokus = new List <int[, ]>();
List <int>[,] candidateBoardBase = new List <int> [9, 9];
for (int r = 0; r < candidateBoardBase.GetLength(0); r++)
{
for (int c = 0; c < candidateBoardBase.GetLength(1); c++)
{
candidateBoardBase[r, c] = Enumerable.Range(1, 9).ToList();
}
}
using (var sudokuFile = File.OpenText(@"...\...\Resources\p096_sudoku.txt"))
{
int[,] sudokuBoard = new int[9, 9];
while (sudokuFile.ReadLine() != null)
{
readSudokuBoard(sudokuBoard, sudokuFile);
List <int>[,] candidateBoard = Functions.getDeepCopy <List <int> [, ]>(candidateBoardBase);
updateSudokuBoards(sudokuBoard, candidateBoard);
int[,] solution = getSudokuSolution(sudokuBoard, candidateBoard);
//printSudoku(solution);
ans += solution[0, 0] * 100 + solution[0, 1] * 10 + solution[0, 2];
}
}
Console.WriteLine(ans);
}
public static SinglyLinkedList <Point> FindPaths(List <ICreature>[,] map, Point start, Point finish)
{
if (start == finish)
{
return(null);
}
var queue = new Queue <SinglyLinkedList <Point> >();
var visited = new HashSet <Point>();
queue.Enqueue(new SinglyLinkedList <Point>(start));
var width = map.GetLength(0);
var height = map.GetLength(1);
while (queue.Count > 0)
{
var path = queue.Dequeue();
var point = path.Value;
if (!visited.Contains(point) && point.X >= 0 && point.X < width && point.Y >= 0 && point.Y < height - 1 &&
!map[point.X, point.Y].Any(x => x is Terrain) &&
(map[point.X, point.Y + 1].Any(x => x is Terrain || x is Stairs) ||
(map[point.X, point.Y].Any(x => x is Stairs) && path.Previous.Value.Y < point.Y)))
{
if (finish == point)
{
return(path.Reverse());
}
visited.Add(point);
AddPoint(queue, path);
}
}
return(null);
}
public void SauvegarderCarte(List<Tuile>[,] tuileArray, String asset)
{
ecrireCarte = new System.IO.StreamWriter(asset);
int width = tuileArray.GetLength(0);
int height = tuileArray.GetLength(1);
ecrireCarte.WriteLine(width);
ecrireCarte.WriteLine(height);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
string str = "";
foreach (Tuile tuile in tuileArray[x, y])
{
str += tuile.type;
if (tuile.hauteur < 10)
str += "0";
str += tuile.hauteur;
}
ecrireCarte.WriteLine(str);
}
}
ecrireCarte.Close();
Console.WriteLine("CARTE SAUVEGARDEE");
}
/// <summary>
/// Gets conditional probability table plot data.
/// </summary>
/// <param name="array">
/// The array representing the conditional probability table.
/// </param>
/// <param name="mapping">
/// The data mapping.
/// </param>
/// <param name="rowLabel">
/// The row label.
/// </param>
/// <param name="columnLabel">
/// The column label.
/// </param>
/// <returns>
/// The conditional probability table plot data.
/// </returns>
public static Dictionary <string, Dictionary <string, List <Tweet> > > GetTweetMatrix(
List <Tweet>[,] array,
CrowdDataMapping mapping,
string rowLabel,
string columnLabel)
{
Debug.Assert(
array.GetLength(0) == mapping.LabelCount && array.GetLength(1) == mapping.LabelCount,
"Inconsistent arguments");
var result = new Dictionary <string, Dictionary <string, List <Tweet> > >();
for (var i = 0; i < mapping.LabelCount; i++)
{
var rowName = $"{mapping.LabelValueToString[mapping.LabelIndexToValue[i]]} ({rowLabel})";
var row = new Dictionary <string, List <Tweet> >();
for (var j = 0; j < mapping.LabelCount; j++)
{
var colName = $"{mapping.LabelValueToString[mapping.LabelIndexToValue[j]]} ({columnLabel})";
row[colName] = array[i, j];
}
result[rowName] = row;
}
return(result);
}
public void Draw(SpriteBatch spriteBatch)
{
foreach (Tile drawTile in DrawTiles)
{
if (drawTile != null)
{
drawTile.Draw(spriteBatch);
}
}
for (int x = 0; x < ObjectsInArea.GetLength(0); x++)
{
for (int y = 0; y < ObjectsInArea.GetLength(1); y++)
{
int c = ObjectsInArea[x, y].Count;
if (c == 1)
{
spriteBatch.Draw(DrawTiles[0, 0].Texture, new Rectangle(x * 64, y * 64, 64, 64), Color.Red);
}
if (c == 2)
{
spriteBatch.Draw(DrawTiles[0, 0].Texture, new Rectangle(x * 64, y * 64, 64, 64), Color.Green);
}
}
}
}
/// <summary>
/// Maps the indicated point that has been rotated, back to the initial position.
///
/// If that initial position is not in the first quadrant, it's reflecte back into it.
/// </summary>
/// <param name="mapPoint">Point that should be mapped to the rotationMatrix.</param>
/// <param name="angle">Angle that the point has been rotated.</param>
/// <param name="rotationMatrix">All the Point lists that make up the rotation data. Indeces map to initial position values.</param>
private static void MapRotatedPoint(Point mapPoint, int angle, List <Point>[,] rotationMatrix)
{
// Rotate point back to it's generic grid position
Point rotated = RotatePointAroundCenter(-angle, mapPoint);
// Get hash values for the rotated point
int row = rotated.Y + MAX_FLAKE_RADIUS;
int col = rotated.X + MAX_FLAKE_RADIUS;
// If within the bounds of the matrix && the first quadrant
if (col >= MAX_FLAKE_RADIUS && col < rotationMatrix.GetLength(1) &&
row >= MAX_FLAKE_RADIUS && row < rotationMatrix.GetLength(0))
{
// If point list hasn't been set, set it
if (rotationMatrix[row, col] == null)
{
rotationMatrix[row, col] = new List <Point>();
}
// Add the point if it's not already there
if (!rotationMatrix[row, col].Contains(mapPoint))
{
rotationMatrix[row, col].Add(mapPoint);
}
}
}
void MarkCircle(ref List <int>[,] grid, Circle circle, float cellSize, int mark)
{
int cellX = (int)(circle.center.x / cellSize);
int cellY = (int)(circle.center.y / cellSize);
int offset = (int)(circle.radius / cellSize);
int markStartX = Mathf.Max(0, cellX - offset);
int markEndX = Mathf.Min(cellX + offset, grid.GetLength(0) - 1);
int markStartY = Mathf.Max(0, cellY - offset);
int markEndY = Mathf.Min(cellY + offset, grid.GetLength(1) - 1);
for (int x = markStartX; x <= markEndX; x++)
{
for (int y = markStartY; y <= markEndY; y++)
{
float dist = Vector2.Distance(new Vector2(cellX, cellY), new Vector2(x, y));
if (dist <= circle.radius / 2 / cellSize)
{
if (grid[x, y] == null)
{
grid[x, y] = new List <int>()
{
mark
}
}
;
else
{
grid[x, y].Add(mark);
}
}
}
}
}
/// <summary>
/// Updates a Sudoku board and a candidate Sudoku board
/// </summary>
/// <param name="board">Int[,]</param>
/// <param name="candidateBoard">List<int>[,]</param>
static void updateSudokuBoards(int[,] board, List <int>[,] candidateBoard)
{
for (int r = 0; r < board.GetLength(0); r++)
{
for (int c = 0; c < board.GetLength(1); c++)
{
if (board[r, c] != 0)
{
removeSudokuCandidateRow(board[r, c], r, candidateBoard);
removeSudokuCandidateColumn(board[r, c], c, candidateBoard);
removeSudokuCandidateBlock(board[r, c], r, c, candidateBoard);
candidateBoard[r, c] = new List <int>();
}
}
}
for (int r = 0; r < candidateBoard.GetLength(0); r++)
{
for (int c = 0; c < candidateBoard.GetLength(1); c++)
{
if (candidateBoard[r, c].Count == 1)
{
board[r, c] = candidateBoard[r, c][0];
candidateBoard[r, c] = new List <int>();
updateSudokuBoards(board, candidateBoard);
}
}
}
}
public Map(RenderingTextureAllocator Allocator)
{
// Create map
_map = new List <Entry> [Allocator.Size.Z, Allocator.Size.Y / _mapGranularity, Allocator.Size.X / _mapGranularity];
for (int z = 0; z < _map.GetLength(0); ++z)
{
for (int y = 0; y < _map.GetLength(1); ++y)
{
for (int x = 0; x < _map.GetLength(2); ++x)
{
_map[z, y, x] = new List <Entry>();
}
}
}
// Fill map
foreach (KeyValuePair <RenderingTexture, VectorInt3> availableTexture in Allocator.AvailableTextures)
{
Entry @ref = new Entry(availableTexture);
VectorInt2 startPixel = new VectorInt2(availableTexture.Value.X, availableTexture.Value.Y);
VectorInt2 endPixel = startPixel + (availableTexture.Key.To - availableTexture.Key.From);
VectorInt2 startBlock = startPixel / _mapGranularity;
VectorInt2 endBlock = (endPixel + new VectorInt2(_mapGranularity - 1, _mapGranularity - 1)) / _mapGranularity;
for (int x = startBlock.X; x < endBlock.X; ++x)
{
for (int y = startBlock.Y; y < endBlock.Y; ++y)
{
_map[availableTexture.Value.Z, y, x].Add(@ref);
}
}
}
}
public void SaveToFile(string outputFileName, List <RelationshipDegreeUI>[,] dataArray)
{
using (StreamWriter outfile = new StreamWriter(outputFileName))
{
for (int line = 0; line < dataArray.GetLength(0); line++)
{
string content = "";
for (int column = 0; column < dataArray.GetLength(1); column++)
{
foreach (var cell in dataArray[line, column])
{
if (cell != null)
{
content += cell.RelationshipDegreeNumber + ";";
}
}
if (content != "")
{
content = content.Remove(content.Length - 1);
}
content += ",";
}
if (content != "")
{
content = content.Remove(content.Length - 1);
}
outfile.WriteLine(content);
}
}
}
public void GenerateRoad(OrientedPoint seed, int length, bool major, bool rev)
{
// Inherit some variables from parents
float offset = GetComponentInParent <RoadNetwork>()._offset;
int interval = GetComponentInParent <RoadNetwork>()._interval;
int scale = GetComponentInParent <CityGenerator>().scale;
List <OrientedPoint>[,] roadPoints = GetComponentInParent <RoadNetwork>().roadPoints;
field = new Field();
path = field.Trace(field.SampleOrthogonal, scale, offset, major, transform.position + seed.position, rev, length, roadPoints);
if (path.Count == 0)
{
return;
}
// Update neighbor of first point in path
path[0].neighbors.Add(seed);
Extrude(path);
// Pass road path to parent and round to chunk
foreach (OrientedPoint point in path)
{
int indX = ((int)(point.position.x / 10) + roadPoints.GetLength(0) / 2);
int indZ = ((int)(point.position.z / 10) + roadPoints.GetLength(1) / 2);
GetComponentInParent <RoadNetwork>().roadPoints[indX, indZ].Add(point);
}
}
public void show_Synthesis_of_Priority(string[] header, double[,] value)
{
List <string>[] manuals_on_table = new List <string> [value.GetLength(0)];
double sum = 0;
for (int i = 0; i < manuals_on_table.GetLength(0); i++)
{
manuals_on_table[i] = new List <string>();
manuals_on_table[i].Add(header[i]);
double hasil_kali = 1;
for (int j = 0; j < value.GetLength(1); j++)
{
manuals_on_table[i].Add(Math.Round(value[i, j], 2, MidpointRounding.AwayFromZero).ToString());
hasil_kali = hasil_kali * value[i, j];
}
manuals_on_table[i].Add(Math.Round(hasil_kali, 2, MidpointRounding.AwayFromZero).ToString());
double Ai = Math.Pow(hasil_kali, (1 / Convert.ToDouble(value.GetLength(1))));
manuals_on_table[i].Add(Math.Round(Ai, 2, MidpointRounding.AwayFromZero).ToString());
sum = sum + Math.Pow(hasil_kali, (1 / Convert.ToDouble(value.GetLength(1))));
}
Console.WriteLine("SUM : " + sum.ToString());
for (int i = 0; i < manuals_on_table.GetLength(0); i++)
{
double Xi = (Convert.ToDouble(manuals_on_table[i].LastOrDefault()) / sum);
manuals_on_table[i].Add(Math.Round(Xi, 2, MidpointRounding.AwayFromZero).ToString());
dgv_manuals.Rows.Add(manuals_on_table[i].ToArray());
}
}
// updates this grid based on the motion of obj
public void Update(CollidableObject obj, CollisionBox oldBox, CollisionBox newBox)
{
int oldMinX = (int)(oldBox.Min.X / squareSize);
int oldMaxX = (int)(oldBox.Max.X / squareSize);
int oldMinY = (int)(oldBox.Min.Y / squareSize);
int oldMaxY = (int)(oldBox.Max.Y / squareSize);
int newMinX = (int)(newBox.Min.X / squareSize);
int newMaxX = (int)(newBox.Max.X / squareSize);
int newMinY = (int)(newBox.Min.Y / squareSize);
int newMaxY = (int)(newBox.Max.Y / squareSize);
for (int x = oldMinX; x <= oldMaxX; x++)
{
for (int y = oldMinY; y <= oldMaxY; y++)
{
if (x >= 0 && y >= 0 && x < grid.GetLength(0) && y < grid.GetLength(1))
{
grid[x, y].Remove(obj);
}
}
}
for (int x = newMinX; x <= newMaxX; x++)
{
for (int y = newMinY; y <= newMaxY; y++)
{
if (x >= 0 && y >= 0 && x < grid.GetLength(0) && y < grid.GetLength(1))
{
grid[x, y].Add(obj);
}
}
}
}
private List <CameraVisibility> getUniqueVisibilities(List <CameraVisibility>[,,] camVisibilitiesAtPos)
{
List <CameraVisibility> list = new List <CameraVisibility>();
int length = camVisibilitiesAtPos.GetLength(0);
int length2 = camVisibilitiesAtPos.GetLength(1);
int length3 = camVisibilitiesAtPos.GetLength(2);
int num = 0;
for (int i = 0; i < length; i++)
{
for (int j = 0; j < length2; j++)
{
for (int k = 0; k < length3; k++)
{
List <CameraVisibility> list2 = camVisibilitiesAtPos[i, j, k];
if (list2 != null)
{
for (int l = 0; l < list2.Count; l++)
{
list.Add(list2[l]);
num++;
}
}
}
}
}
return(list);
}
public void AddSolids()
{
SolidChunks = new List <Tile> [Width / CHUNK_FACTOR, Height / CHUNK_FACTOR];
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
int chunkX = x / CHUNK_FACTOR;
int chunkY = y / CHUNK_FACTOR;
if (chunkX >= SolidChunks.GetLength(0))
{
chunkX--;
}
if (chunkY >= SolidChunks.GetLength(1))
{
chunkY--;
}
if (SolidChunks[chunkX, chunkY] == null)
{
SolidChunks[chunkX, chunkY] = new List <Tile>();
}
AddSolidTile(0, x, y);
}
}
}
static List <Point <byte> >[,] StworzTabliceSzachowanPoPrzekatnej(int rozmiar)
{
var rozmiarTablicy = rozmiar * rozmiar;
var tablicaSzachowan = new List <Point <byte> > [rozmiar, rozmiar];
for (int i = 0; i < tablicaSzachowan.GetLength(0); i++)
{
for (int j = 0; j < tablicaSzachowan.GetLength(1); j++)
{
var lista = new List <Point <byte> >();
for (int k = 0; k < rozmiar; k++)
{
var y = j - (i - k);
if (y >= 0 && y < rozmiar)
{
lista.Add(new Point <byte> {
X = (byte)k, Y = (byte)y
});
}
y = j + (i - k);
if (y >= 0 && y < rozmiar)
{
lista.Add(new Point <byte> {
X = (byte)k, Y = (byte)y
});
}
}
tablicaSzachowan[i, j] = lista.GroupBy(a => new { a.X, a.Y }).Select(a => a.Last()).ToList();
}
}
return(tablicaSzachowan);
}
private void InsertDataIntoList(string[] lines)
{
int numOfLines = lines.Length; //number of lines in the csv file
for (int k = 0; k < numOfMagics; k++)
{
for (int i = 0; i < magics.GetLength(1); i++)
{
for (int j = 0; j < magics.GetLength(2); j++)
{
magics[k, i, j] = new List <double>();
}
}
}
//runs on all the rows
for (int i = 0; i < numOfLines; i++)
{
string[] line = lines[i].Split(',');
//for each row, checks to which magic it belongs
for (int j = 1; j < line.Length; j++)
{
if (line[j] != "")
{
magics[(int)line[0][1] - 48, (int)line[0][2] - 48, (int)line[0][3] - 48].Add(double.Parse(line[j]));
}
}
}
}
public Entry Lookup(VectorInt3 pos)
{
int mapX = pos.X / _mapGranularity;
int mapY = pos.Y / _mapGranularity;
if (mapX < 0 || mapY < 0 || mapX >= _map.GetLength(2) || mapY >= _map.GetLength(1))
{
return(null);
}
List <Entry> candidates = _map[pos.Z, mapY, mapX];
foreach (Entry candidate in candidates)
{
if ((pos.X >= candidate.Pos.X) && (pos.Y >= candidate.Pos.Y))
{
VectorInt2 size = candidate.Texture.To - candidate.Texture.From;
if ((pos.X < (candidate.Pos.X + size.X)) && (pos.Y < (candidate.Pos.Y + size.Y)))
{
return(candidate);
}
}
}
return(null);
}
private static List <node> GetAdjacentNodes(node root, List <node>[,] nodeMap)
{
var ret = new List <node>();
if (root.X != 0)
{
ret.AddRange(nodeMap[root.X - 1, root.Y].Where(n => n.Equipped == root.Equipped));
}
if (root.Y != 0)
{
ret.AddRange(nodeMap[root.X, root.Y - 1].Where(n => n.Equipped == root.Equipped));
}
if (root.X != nodeMap.GetLength(0) - 1)
{
ret.AddRange(nodeMap[root.X + 1, root.Y].Where(n => n.Equipped == root.Equipped));
}
if (root.Y != nodeMap.GetLength(1) - 1)
{
ret.AddRange(nodeMap[root.X, root.Y + 1].Where(n => n.Equipped == root.Equipped));
}
ret.AddRange(nodeMap[root.X, root.Y].Where(n => n.Equipped != root.Equipped));
return(ret);
// return nodes.Where(n =>
// (n.X == root.X && n.Y == root.Y - 1 && n.Equipped == root.Equipped) ||
// (n.X == root.X && n.Y == root.Y + 1 && n.Equipped == root.Equipped) ||
// (n.X == root.X + 1 && n.Y == root.Y && n.Equipped == root.Equipped) ||
// (n.X == root.X - 1 && n.Y == root.Y && n.Equipped == root.Equipped) ||
// (n.X == root.X && n.Y == root.Y && n.Equipped != root.Equipped)).ToList();
}
private void DrawFabric(List <int>[,] fabric, bool clearScreen = false)
{
if (clearScreen)
{
Console.Clear();
}
int rowLength = fabric.GetLength(0);
int colLength = fabric.GetLength(1);
for (int i = 0; i < rowLength; i++)
{
for (int j = 0; j < colLength; j++)
{
if (fabric[i, j].Count == 1)
{
Console.Write(fabric[i, j][0]);
}
else if (fabric[i, j].Count > 1)
{
Console.Write("X");
}
else
{
Console.Write(".");
}
}
Console.WriteLine();
}
}
public int length; // = 5000; // Global max length for each road generated
public void GenerateRoadNetwork(OrientedPoint startingSeed, int iter, int length, int interval)
{
// Reference to parent
CityGenerator parent = gameObject.GetComponentInParent <CityGenerator>();
_interval = parent.interval;
_offset = parent.offset;
_length = parent.length;
_iter = parent.length;
ctr = _iter;
// Create and initialize new lookup matrix (chunks)
roadPoints = new List <OrientedPoint> [500, 500];
for (int x = 0; x < roadPoints.GetLength(0); x++)
{
for (int z = 0; z < roadPoints.GetLength(1); z++)
{
roadPoints[x, z] = new List <OrientedPoint>();
}
}
// Clear the queue before new generation starts
seeds.Clear();
// Function structure
GameObject mainRoad = new GameObject("Main Road");
mainRoad.AddComponent <Road>().transform.parent = this.transform;
Road road = mainRoad.GetComponent <Road>();
// Generate the first road from the starting point
road.GenerateRoad(startingSeed, length, true, false);
// Extract seeds from the road and add to queue
AddCandidatesToQueue(road.path, interval);
while (seeds.Count != 0 && iter > 0)
{
OrientedPoint roadSeed = seeds.Dequeue();
GameObject leftRoad = GenerateChildRoad();
GameObject rightRoad = GenerateChildRoad();
// Generate the subroads with alternating major flag
// Flip the major flag for the next road
bool major = !roadSeed.major;
Road left = leftRoad.GetComponent <Road>();
Road right = rightRoad.GetComponent <Road>();
// Generate roads in either direction from seed
GenerateRoads(left, right, roadSeed, interval, major);
iter--;
ctr--;
}
}
static void Main(string[] args)
{
int[] s = { 0, 1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12, 24 };
int[] e = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 24 };
List <int>[,] result = new List <int> [13, 13];
for (int i = 0; i < result.GetLength(0); ++i)
{
for (int j = 0; j < result.GetLength(1); ++j)
{
result[i, j] = new List <int>();
}
}
for (int j = 0; j < 13; ++j)
{
for (int i = 0; i < j - 1; ++i)
{
//考虑s[ij] i结束之后 j开始之前，活动集合存不存在
//e[i] s[j] 这个时间之内的所有活动
List <int> sij = new List <int>();
for (int number = 1; number < s.Length - 1; ++number)
{
if (s[number] >= e[i] && e[number] <= s[j])
{
sij.Add(number);
}
}
if (sij.Count > 0)
{
//result[i,] = max(result[i, k] + result[k, j] + k}
int maxCount = 0;
List <int> tempList = new List <int>();
foreach (int number in sij)
{
int count = result[i, number].Count + result[number, j].Count + 1;
if (maxCount < count)
{
maxCount = count;
tempList = result[i, number].Union(result[number, j]).ToList();
tempList.Add(number);
}
}
result[i, j] = tempList;
}
}
}
foreach (int temp in result[0, 12])
{
Console.WriteLine(temp);
}
Console.ReadKey();
}
public List <GameObject> get(int x, int y)
{
if (x < 0 || x >= mapArray.GetLength(0) || y < 0 || y >= mapArray.GetLength(1))
{
return(null);
}
return(mapArray [x, y]);
}
public Level(string map, int numberPlayer)
{
Map = MapCreator.CreateMap(map, numberPlayer);
Width = Map.GetLength(0);
Height = Map.GetLength(1);
TextInitiallyMap = map;
CountBeer = DeemBeer();
}
public UnitMap(Tilemap tm)
{
umap = new List<Unit>[tm.NumX, tm.NumY];
for (int i = 0; i < umap.GetLength(0); i++)
for (int e = 0; e < umap.GetLength(1); e++)
umap[i, e] = new List<Unit>();
}
public UnitMap(int w, int h)
{
umap = new List<Unit>[w, h];
for (int i = 0; i < umap.GetLength(0); i++)
for (int e = 0; e < umap.GetLength(1); e++)
umap[i, e] = new List<Unit>();
}
internal void SetLinesMX(List<CLine>[,] mx)
{
this.mx = mx;
if (mx != null)
{
maxX = mx.GetLength(0);
maxY = mx.GetLength(1);
}
}
private void FillArrayWithEmptyLists()
{
for (int x = 0; x < pointarray.GetLength(0); x++)
{
for (int y = 0; y < pointarray.GetLength(1); y++)
{
FillWithEmptyPointList(x, y);
}
}
}
private List <KBatchedAnimController> GetControllerList(Vector2I chunk_xy)
{
List <KBatchedAnimController> result = null;
if (controllerGrid != null && 0 <= chunk_xy.x && chunk_xy.x < controllerGrid.GetLength(0) && 0 <= chunk_xy.y && chunk_xy.y < controllerGrid.GetLength(1))
{
result = controllerGrid[chunk_xy.x, chunk_xy.y];
}
return(result);
}
private void PaintGraphLog()
{
GameObject emptyParent = new GameObject();
maxAmountData = (int)Mathf.Log10(maxAmountData);
emptyParent.transform.position = spawnArea; //TODO remove spawnArea variable completely?
emptyParent.AddComponent <Rigidbody>();
emptyParent.GetComponent <Rigidbody>().isKinematic = true;
emptyParent.GetComponent <Rigidbody>().useGravity = false;
emptyParent.AddComponent <BoxCollider>();
emptyParent.GetComponent <BoxCollider>().size = new Vector3(graphSize, graphSize, 1); //TODO change 1
//TODO change center of collider
emptyParent.layer = 8;
emptyParent.tag = "Mark";
for (int i = 0; i < splitMatrix.GetLength(0); i++)
{
for (int j = 0; j < splitMatrix.GetLength(1); j++)
{
float amountData = splitMatrix[i, j].Count;
float height = 0;
if (amountData != 0)
{
height = (float)Mathf.Log10(amountData) / maxAmountData;
}
List <LabeledData> data = splitMatrix[i, j];
GameObject tmp = GameObject.CreatePrimitive(PrimitiveType.Cube);
Destroy(tmp.GetComponent <BoxCollider>());
Destroy(tmp.GetComponent <Rigidbody>());
tmp.transform.localScale = new Vector3(columnSizeX, columnSizeY, height);
tmp.transform.position = new Vector3(spawnArea.x + ((i * columnSizeX) - (1 / 2)),
spawnArea.y + ((j * columnSizeY) - (1 / 2)),
spawnArea.z - height / 2);
tmp.transform.parent = emptyParent.transform;
tmp.GetComponent <Renderer>().material = barMaterial;
Color barColor = GetComponent <GradientManager>().getColor(height);
tmp.GetComponent <Renderer>().material.color = barColor;
if (saveList)
{
tmp.AddComponent <GraphBarHandler>();
tmp.GetComponent <GraphBarHandler>().dataSet = data;
tmp.GetComponent <GraphBarHandler>().SetDefaultColor(barColor);
}
}
}
emptyParent.transform.rotation = Quaternion.Euler(90f, 0f, 0f);
emptyParent.transform.position = GetComponent <PlayerParts>().head.transform.position + GetComponent <PlayerParts>().head.transform.forward * 2
- GetComponent <PlayerParts>().head.transform.up;
}
//Get the cell contents at the requested grid co-ordinate, if the co-ordinates are outside of the bounds of the grid return an empty list
public List <T> GetCellContents(int x, int y)
{
if (x >= 0 && y >= 0 && x < gridObjects.GetLength(0) && y < gridObjects.GetLength(1))
{
return(gridObjects[x, y]);
}
else
{
return(new List <T>());
}
}
private void InitializeFabric()
{
_fabric = new List <int> [1000, 1000];
for (var i = 0; i < _fabric.GetLength(0); i++)
{
for (var j = 0; j < _fabric.GetLength(1); j++)
{
_fabric[i, j] = new List <int>();
}
}
}
private void deregisterOnGrid(MonoBehaviour objectController)
{
for (int x = 0; x < grid.GetLength(0); x++)
{
for (int y = 0; y < grid.GetLength(1); y++)
{
grid[x, y] = grid[x, y].Where(square => square.referenceToObject.objectController != objectController)
.ToList();
}
}
}
public void InitCarte(String asset)
{
lireCarte = new System.IO.StreamReader(asset);
carteArray = new List<string>[Convert.ToInt32(lireCarte.ReadLine()), Convert.ToInt32(lireCarte.ReadLine())];
for (int x = 0; x < carteArray.GetLength(0); x++)
for (int y = 0; y < carteArray.GetLength(1); y++)
carteArray[y, x] = new List<string>();
lireCarte.Close();
}
private int grid_offset = 10; //because space is centered at (0,0,0)
#endregion Fields
#region Constructors
//constructor
public GridStructure(int cubeLength, int max_size)
{
GRID_BLOCK_SIZE = max_size;
grid_offset = (cubeLength / GRID_BLOCK_SIZE) / 2;
gridLength = (cubeLength / GRID_BLOCK_SIZE) + 1;
grid = new List<GridObjectInterface>[gridLength, gridLength, gridLength];
//initialise grid structure
for (int x = 0; x < grid.GetLength(0); x++)
for (int y = 0; y < grid.GetLength(1); y++)
for (int z = 0; z < grid.GetLength(2); z++)
grid[x, y, z] = new List<GridObjectInterface>();
}
public KMeansClusteringModel(double[,] centers, IEnumerable<string> allowedInputVariables)
: base() {
this.name = ItemName;
this.description = ItemDescription;
// disect center matrix into list of double[]
// centers are given as double matrix where number of rows = dimensions and number of columns = clusters
// each column is a cluster center
this.centers = new List<double[]>();
for (int i = 0; i < centers.GetLength(1); i++) {
double[] c = new double[centers.GetLength(0)];
for (int j = 0; j < c.Length; j++) {
c[j] = centers[j, i];
}
this.centers.Add(c);
}
this.allowedInputVariables = allowedInputVariables.ToArray();
}
static string to_string(List<Location>[, ,] data)
{
string data_string = "";
for (int i = 0, m = data.GetLength(0); i < m; ++i)
{
for (int j = 0, n = data.GetLength(1); j < n; ++j)
{
for (int k = 0, o = data.GetLength(2); k < o; ++k)
{
//if (data[i, j, k] == null)
//{
// data[i, j, k] = new List<Location>();
//}
for (int l = 0, p = data[i, j, k].Count; l < p; ++l)
{
data_string += data[i, j, k][l].x + "," + data[i, j, k][l].y + " ";
}
}
}
}
return data_string;
/***SCRIPT FOR PARSING INTO INDIVIDUAL FILES, PLEASE KEEP FOR NOW ***/
/*string line;
FileStream f_in = new FileStream("consolidated_by_pos.txt", FileMode.Open, FileAccess.Read);
StreamReader s_in = new StreamReader(f_in);
s_in.ReadLine();
for (int i = 0; i < 5; ++i)
{
for (int j = 0; j < 5; ++j)
{
FileStream f_out = new FileStream("../../../test/fixtures/collected_data/Position_" + i + "_" + j + "_Orientation" + "_" + "0" + ".txt", FileMode.Create, FileAccess.Write);
StreamWriter s_out = new StreamWriter(f_out);
s_out.WriteLine("1,1 4 1");
for (int k = 0; k < 4; ++k)
{
line = s_in.ReadLine();
s_out.WriteLine(line);
}
s_out.Close();
f_out.Close();
}
}
s_in.Close();
f_in.Close();*/
}
/*
* Populates the collision grid by bucketizing each unit on the map into a cell
* around which collisions will be processed
*/
public List<GameUnit>[,] ConstructCollisionGrid(List<GameUnit> units, Level level)
{
List<GameUnit>[,] grid = new List<GameUnit>[
(int)level.Width / CELL_SIZE, (int)level.Height / CELL_SIZE];
foreach (GameUnit unit in units)
{
int x_index = (int)MathHelper.Clamp((unit.Position.X / CELL_SIZE), 0, grid.GetLength(1)-1);
int y_index = (int)MathHelper.Clamp((unit.Position.Y / CELL_SIZE), 0, grid.GetLength(0)-1);
if (grid[y_index, x_index] == null)
{
grid[y_index, x_index] = new List<GameUnit>();
}
grid[y_index, x_index].Add(unit);
}
return grid;
}
public Carte(MoteurPhysique moteurPhysique, List<string>[,] charArray, Vector2 camera, int tileWidth, int tileHeight, int tileStepX, int tileStepY)
{
this.moteurPhysique = moteurPhysique;
this.camera = camera;
this.tileWidth = tileWidth;
this.tileHeight = tileHeight;
this.tileStepX = tileStepX;
this.tileStepY = tileStepY;
tuileArray = new List<Tuile>[charArray.GetLength(0), charArray.GetLength(1)];
for (int x = 0; x < charArray.GetLength(0); x++)
for (int y = 0; y < charArray.GetLength(1); y++)
tuileArray[y, x] = new List<Tuile>();
InitTileArray(charArray);
tuileHover = new Vector2(10, 10);
}
public ArrayBasedLocations(List<Location>[,,] location_data)
{
this.SignalStrengthCount = (uint)location_data.GetLength(0);
this.NodeCount = (uint)location_data.GetLength(1);
this.OrientationCount = (uint)location_data.GetLength(2);
this.data = new List<Location>[this.SignalStrengthCount, this.NodeCount, this.OrientationCount];
for(int i = 0; i < this.SignalStrengthCount; ++i)
{
for(int j = 0; j < this.NodeCount; ++j)
{
for(int k = 0; k < this.OrientationCount; ++k)
{
this.data[i, j, k] = new List<Location>();
this.data[i,j,k].AddRange(location_data[i,j,k]);
}
}
}
}
public string to_string(List<Location>[, ,] data)
{
string data_string = "";
for (int i = 0, m = data.GetLength(0); i < m; ++i)
{
for (int j = 0, n = data.GetLength(1); j < n; ++j)
{
for (int k = 0, o = data.GetLength(2); k < o; ++k)
{
//if (data[i, j, k] == null)
//{
// data[i, j, k] = new List<Location>();
//}
for (int l = 0, p = data[i, j, k].Count; l < p; ++l)
{
data_string += data[i, j, k][l].x + "," + data[i, j, k][l].y + " ";
}
}
}
}
return data_string;
}
public void addToLayer(List<byte[]>[,] layerBitmaps, int xStart, int yStart)
{
for (int y = 0; y < yRange; y++)
{
for (int x = 0; x < xRange; x++)
{
if (xStart + x < layerBitmaps.GetLength(0) && yStart + y - yRange + 1 >= 0)
{
layerBitmaps[xStart + x, yStart + y - yRange + 1].Add(tiles[x, y]);
}
}
}
}
public NoteThread(CellState[,] notes, int measureLength, double timeSignature)
{
this.notes = new List<Note>();
this.timeSignature = timeSignature;
for (int i = 0; i < notes.GetLength(0); i++)
{
for (int j = 0; j < notes.GetLength(1); j++)
{
if (notes[i, j] == CellState.START)
{
double duration = Automatone.getBeatResolution();
int k = j + 1;
while (k < notes.GetLength(1) && notes[i, k] == CellState.HOLD)
{
duration += Automatone.getBeatResolution();
k++;
}
this.notes.Add(new Note(new NoteName((byte)((i + Automatone.LOWEST_NOTE_CHROMATIC_NUMBER) % MusicTheory.OCTAVE_SIZE)), (byte)((i + Automatone.LOWEST_NOTE_CHROMATIC_NUMBER) / MusicTheory.OCTAVE_SIZE), duration, (int)(j / measureLength), (j % measureLength) * Automatone.getBeatResolution()));
}
}
}
}
public Carte(List<string>[,] charArray, Vector2 camera, int tileWidth, int tileHeight, int tileStepX, int tileStepY)
{
this.camera = camera;
this.tileWidth = tileWidth;
this.tileHeight = tileHeight;
this.tileStepX = tileStepX;
this.tileStepY = tileStepY;
tuileArray = new List<Tuile>[charArray.GetLength(0), charArray.GetLength(1)];
for (int x = 0; x < charArray.GetLength(0); x++)
for (int y = 0; y < charArray.GetLength(1); y++)
tuileArray[y, x] = new List<Tuile>();
InitTileArray(charArray);
inSelect = false;
initialPos = Vector2.Zero;
tuileHover = new Vector2(10, 10);
rectSelect = new Rectangle(7, 7, 3, 3);
}
public DeckDealer(List<string>[] players, IList<string> deck, int handOut)
{
if (players == null || deck == null) throw new Exception("One of arguments is null");
if (handOut<1 || handOut> deck.Count/ players.GetLength(0)) throw new Exception("Wrong number of cards to handout");
foreach (var variable in players)
{
for (var i = 0; i < handOut; i++)
{
var tmpCard = deck.ElementAt(0);
Console.WriteLine("Card taken form deck "+tmpCard);
deck.RemoveAt(0);
Console.WriteLine("Next card should be "+deck.ElementAt(0));
variable.Add(tmpCard);
}
}
_tabLists = players;
}
public void AddDim(Vector2 dim)
{
List<Tuile>[,] carteAux = new List<Tuile>[(int)dim.X, (int)dim.Y];
for (int x = 0; x < tuileArray.GetLength(0); x++)
for (int y = 0; y < tuileArray.GetLength(1); y++)
carteAux[x, y] = tuileArray[x, y];
for (int x = 0; x < carteAux.GetLength(0); x++)
{
carteAux[x, carteAux.GetLength(1) - 1] = new List<Tuile>();
carteAux[x, carteAux.GetLength(1) - 1].Add(new Tuile(new Vector2(x, carteAux.GetLength(1) - 1), new Vector2(7, 0), false, 0));
}
for (int y = 0; y < carteAux.GetLength(1); y++)
{
carteAux[carteAux.GetLength(0) - 1, y] = new List<Tuile>();
carteAux[carteAux.GetLength(0) - 1, y].Add(new Tuile(new Vector2(carteAux.GetLength(0) - 1, y), new Vector2(7, 0), false, 0));
}
tuileArray = carteAux;
Console.WriteLine("new dim : " + tuileArray.GetLength(0));
}
private void AutoTest(object sender, DoWorkEventArgs e)
{
object[] param = (object[])e.Argument;
int avg_cnt = (int)param[0];
int KNN_K = (int)param[1];
int KNNHC_K = (int)param[2];
string db_file_name = (string)param[3];
string data_file_name = (string)param[4];
double start_snr = (double)param[5];
double stop_snr = (double)param[6];
double step_snr = (double)param[7];
int ray_num = (int)param[8];
Transmitter.EMIT_OPTION emit_opt = (Transmitter.EMIT_OPTION)param[9];
Noise_Type noise_type = (Noise_Type)param[10];
double alpha = (double)param[11];
int sample_cnt = (int)param[12];
Signal_Type signal_type = (Signal_Type)param[13];
System.IO.FileStream data_fs = new FileStream(data_file_name, FileMode.Create, FileAccess.Write, FileShare.Read);
System.Runtime.Serialization.IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
FileStream fs = new FileStream(db_file_name, FileMode.Open, FileAccess.Read, FileShare.Read);
FingerprintDataBase fdb = (FingerprintDataBase)formatter.Deserialize(fs);
fs.Close();
Point pt_real = new Point();
foreach (Transmitter trans in this.viz_rps.Map.Transmitters)
pt_real = trans.Location;
double[] snrs = new double[(int)((stop_snr - start_snr) / step_snr) + 1];
for(int i = 0; i < snrs.Length; i++)
snrs[i] = start_snr + i * step_snr;
foreach (Transmitter trans in this.viz_rps.Map.Transmitters)
{
trans.Reset();
trans.EmitRays(ray_num, emit_opt); //各发射机辐射波束
foreach (Receiver rec in this.viz_rps.Map.Receivers)
{
rec.Reset();
if (this.viz_rps.Map.IsLOS(trans.Location, rec.Location)) //若存在LOS情况
{
LineSegment segLOS = new LineSegment(trans.Location, rec.Location);
Ray rayLOS = new Ray(trans, new LineSegment[] { segLOS }, segLOS.DirectionRadian, trans.CenterFrequency, trans.EmitPower * trans.Gain, trans.EmitPower * trans.Gain, true);
rec.AcceptRay(rayLOS, this.viz_rps.Map);
}
}
foreach (Ray ray in trans.Rays) //更新每条ray, 若被接收，则更新接收它的接收机
{
Receiver rec = null;
while (!ray.Update(this.viz_rps.Map, out rec)) ;
if (rec != null)
rec.AcceptRay(ray, this.viz_rps.Map);
}
}
FingerprintGenerator fg = new FingerprintGenerator();
Dictionary<Fingerprint_Name, Fingerprint> result = new Dictionary<Fingerprint_Name, Fingerprint>();
List<double>[] ray_angles = new List<double>[this.viz_rps.Map.ReceiverCount];
List<double>[] ray_strengths = new List<double>[this.viz_rps.Map.ReceiverCount];
List<double>[] ray_taus = new List<double>[this.viz_rps.Map.ReceiverCount];
int kk = 0;
foreach (Receiver rec in this.viz_rps.Map.Receivers)
{
ray_angles[kk] = new List<double>();
ray_strengths[kk] = new List<double>();
ray_taus[kk] = new List<double>();
foreach (Ray ray in rec.Rays)
{
ray_angles[kk].Add(ray.CurrentDirection);
ray_strengths[kk].Add(ray.FadedPower(this.viz_rps.Map.MeterPixelRatio));
ray_taus[kk].Add(ray.GetLifeSpan(this.viz_rps.Map.MeterPixelRatio));
}
kk++;
}
double[] args = null;
switch (signal_type)
{
case Signal_Type.PSEUDO_DOPPLER:
//if (this.receivers.First().Value.Antenna.AntType != AntennaType.PSEUDO_DOPPLER)
// return null;
Antenna_PseudoDoppler ant = this.viz_rps.Map.receivers.First().Value.Antenna as Antenna_PseudoDoppler;
args = fg.PackArgs_PseudoDoppler(this.viz_rps.Map.receivers.First().Value.FrequencyLow, this.viz_rps.Map.receivers.First().Value.CenterFrequency,
this.viz_rps.Map.receivers.First().Value.SampleFrequency, ant.SwitchFrequency, ant.Radius, ant.AntennaNumber);
break;
}
MWNumericArray[] signals = new MWNumericArray[ray_angles.GetLength(0)];
for (int i = 0; i < signals.Length; i++)
{
signals[i] = new FingerprintGenerator().GenerateSignal_MW(signal_type, ray_angles[i].ToArray(), ray_strengths[i].ToArray(), ray_taus[i].ToArray(), sample_cnt, args);
}
for (int n = 0; n < snrs.Length; n++)
{
double[] sum_errs = new double[6];//SA_single, SA_KNN, SA_KNNHC, S_single, S_KNN, S_KNNHC
for(int i = 0; i < avg_cnt; i++)
{
MWNumericArray[] n_signals = new MWNumericArray[signals.Length];
for (int l = 0; l < signals.Length; l++)
{
n_signals[l] = new FingerprintGenerator().AddNoise_MW(noise_type, signals[l], new double[] { snrs[n] });
}
Dictionary<Fingerprint_Name, Fingerprint> res = new Dictionary<Fingerprint_Name,Fingerprint>();
for (int j = 0; j < Enum.GetNames(new Fingerprint_Name().GetType()).Length; j++ )
res[(Fingerprint_Name)j] = new FingerprintGenerator().GenerateFingerprint(signal_type, (Fingerprint_Name)j, n_signals, args);
this.current_fingerprint = res;
//SA_single
PointF loc_SA_single = fdb.MatchLocation(this.current_fingerprint[Fingerprint_Name.SA], FingerprintDataBase.Match_Strategy.Single, null);
sum_errs[0] += new MathUtils.MathUtility().point_dist(pt_real, loc_SA_single);
//SA_KNN
PointF loc_SA_KNN = fdb.MatchLocation(this.current_fingerprint[Fingerprint_Name.SA], FingerprintDataBase.Match_Strategy.KNN, new double[] { KNN_K });
sum_errs[1] += new MathUtils.MathUtility().point_dist(pt_real, loc_SA_KNN);
//SA_KNNHC
PointF loc_SA_KNNHC = fdb.MatchLocation(this.current_fingerprint[Fingerprint_Name.SA], FingerprintDataBase.Match_Strategy.KNN_HC, new double[] { KNNHC_K });
sum_errs[2] += new MathUtils.MathUtility().point_dist(pt_real, loc_SA_KNNHC);
//S_single
PointF loc_S_single = fdb.MatchLocation(this.current_fingerprint[Fingerprint_Name.S], FingerprintDataBase.Match_Strategy.Single, null);
sum_errs[3] += new MathUtils.MathUtility().point_dist(pt_real, loc_S_single);
//S_KNN
PointF loc_S_KNN = fdb.MatchLocation(this.current_fingerprint[Fingerprint_Name.S], FingerprintDataBase.Match_Strategy.KNN, new double[] { KNN_K });
sum_errs[4] += new MathUtils.MathUtility().point_dist(pt_real, loc_S_KNN);
//S_KNNHC
PointF loc_S_KNNHC = fdb.MatchLocation(this.current_fingerprint[Fingerprint_Name.S], FingerprintDataBase.Match_Strategy.KNN_HC, new double[] { KNNHC_K });
sum_errs[5] += new MathUtils.MathUtility().point_dist(pt_real, loc_S_KNNHC);
bgAutoTest.ReportProgress((int)((n * avg_cnt + i + 1) / (double)(avg_cnt * snrs.Length) * 100));
System.Threading.Thread.Sleep(200);
}
for (int m = 0; m < sum_errs.Length; m++ )
{
double err = sum_errs[m] / avg_cnt;
byte[] tmp = Encoding.ASCII.GetBytes(err.ToString("0.00") + "\t");
data_fs.Write(tmp, 0, tmp.Length);
}
byte[] rn = Encoding.ASCII.GetBytes("\r\n");
data_fs.Write(rn, 0, rn.Length);
}
data_fs.Close();
e.Result = true;
}
public void FillValues(bool fill_positions,bool fill_other_data)
{
if(fill_count <= 0){
return;
}
if(fill_positions){
if(single_position != -1){ //if this value is -1, nothing can be added anyway.
if(positions == null){
positions = new List<int>();
}
while(positions.Count < fill_count){
positions.Add(single_position);
}
}
if(single_layout != -1){
if(layouts == null){
layouts = new List<int>();
}
while(layouts.Count < fill_count){
layouts.Add(single_layout);
}
}
}
if(fill_other_data){
if(single_sprite != -1){
if(sprites == null){
sprites = new List<int>();
}
while(sprites.Count < fill_count){
sprites.Add(single_sprite);
}
}
if(single_sprite_type != -1){
if(sprite_types == null){
sprite_types = new List<int>();
}
while(sprite_types.Count < fill_count){
sprite_types.Add(single_sprite_type);
}
}
if(single_other_data != null){
if(other_data == null){
other_data = new List<float>[single_other_data.GetLength(0)];
for(int i=0;i<other_data.GetLength(0);++i){
other_data[i] = new List<float>();
}
}
int idx = 0;
foreach(List<float> l in other_data){
while(l.Count < fill_count * single_other_data[idx].Count){
foreach(float f in single_other_data[idx]){
l.Add(f);
}
}
++idx;
}
}
}
}
public static void Detect(List<GameObject>[,] clusters, World gameObjects)
{
for (int k = 0; k < gameObjects.Count; k++)
{
for (int i = 0; i < gameObjects[k].Collisions.Count; i++)
CollisionPool.Instance.PutObject(gameObjects[k].Collisions[i]);
gameObjects[k].Collisions.Clear();
}
int ww = clusters.GetLength(1);
int wh = clusters.GetLength(0);
// обход по кластерам
for (int wj = 0; wj < wh; wj++)
for (int wi = 0; wi < ww; wi++)
{
// обход по окресности кластера 3x3
for (int k = 0; k < 5; k++)
{
int di = 0;
int dj = 0;
switch (k)
{
case 0: di = 0; dj = 0; break;
case 1: di = 1; dj = -1; break; // . . 1
case 2: di = 1; dj = 0; break; // . 0 2
case 3: di = 1; dj = 1; break; // . 4 3
case 4: di = 0; dj = 1; break;
}
int clui = (wi + di + ww) % ww;
int cluj = (wj + dj + wh) % wh;
float fx = (wi + di - clui) * Game.ClusterSize;
float fy = (wj + dj - cluj) * Game.ClusterSize;
// обсчёт столкновений 9 кластеров
for (int j = 0; j < clusters[cluj, clui].Count; j++)
for (int i = k == 0 ? j : 0; i < clusters[wj, wi].Count; i++)
{
if (cluj == wj && clui == wi && i == j) // skip self
continue;
var go1 = clusters[cluj, clui][j];
var go2 = clusters[wj, wi][i];
float dx = go2.Position.X - go1.Position.X - fx;
float dy = go2.Position.Y - go1.Position.Y - fy;
float dv = go2.Speed.X - go1.Speed.X;
float du = go2.Speed.Y - go1.Speed.Y;
float rr = go2.Size / 2 + go1.Size / 2;
if (dv == 0f || du == 0f)
{
float ol2 = rr * rr - dx * dx - dy * dy;
if (ol2 > 0)
{
go1.Collisions.Add(CollisionPool.Instance.GetObject(go2, ol2, 0f, new Vector2(dx, dy)));
go2.Collisions.Add(CollisionPool.Instance.GetObject(go1, ol2, 0f, new Vector2(-dx, -dy)));
}
}
else
{
float a = dv * dv + du * du;
float b = 2f * (dv * dx + du * dy);
float c = dx * dx + dy * dy - rr * rr;
float disc = b * b - 4f * a * c;
if (disc < 0)
continue;
float t1 = (-b + Maf.Sqrt(disc)) / (2f * a);
float t2 = (-b - Maf.Sqrt(disc)) / (2f * a);
float min = Math.Min(t1, t2);
float max = Math.Max(t1, t2);
float ol2 = rr * rr - dx * dx - dy * dy;
if (min < 1f && max >= 0f)
{
go1.Collisions.Add(CollisionPool.Instance.GetObject(go2, ol2, min, new Vector2(dx, dy)));
go2.Collisions.Add(CollisionPool.Instance.GetObject(go1, ol2, min, new Vector2(-dx, -dy)));
}
}
}
}
}
}
private MWNumericArray[][] wrap_func(int num, int ray_num, Transmitter.EMIT_OPTION emit_opt, Signal_Type signal_type, int sample_cnt)
{
MWNumericArray[][] signals = new MWNumericArray[num][];
while (num-- > 0)
{
foreach (Transmitter trans in this.viz_rps.Map.Transmitters)
{
trans.Reset();
trans.EmitRays(ray_num, emit_opt); //各发射机辐射波束
foreach (Receiver rec in this.viz_rps.Map.Receivers)
{
rec.Reset();
if (this.viz_rps.Map.IsLOS(trans.Location, rec.Location)) //若存在LOS情况
{
LineSegment segLOS = new LineSegment(trans.Location, rec.Location);
Ray rayLOS = new Ray(trans, new LineSegment[] { segLOS }, segLOS.DirectionRadian, trans.CenterFrequency, trans.EmitPower * trans.Gain, trans.EmitPower * trans.Gain, true);
rec.AcceptRay(rayLOS, this.viz_rps.Map);
}
}
foreach (Ray ray in trans.Rays) //更新每条ray, 若被接收，则更新接收它的接收机
{
Receiver rec = null;
while (!ray.Update(this.viz_rps.Map, out rec)) ;
if (rec != null)
rec.AcceptRay(ray, this.viz_rps.Map);
}
}
FingerprintGenerator fg = new FingerprintGenerator();
Dictionary<Fingerprint_Name, Fingerprint> result = new Dictionary<Fingerprint_Name, Fingerprint>();
List<double>[] ray_angles = new List<double>[this.viz_rps.Map.ReceiverCount];
List<double>[] ray_strengths = new List<double>[this.viz_rps.Map.ReceiverCount];
List<double>[] ray_taus = new List<double>[this.viz_rps.Map.ReceiverCount];
int kk = 0;
foreach (Receiver rec in this.viz_rps.Map.Receivers)
{
ray_angles[kk] = new List<double>();
ray_strengths[kk] = new List<double>();
ray_taus[kk] = new List<double>();
foreach (Ray ray in rec.Rays)
{
ray_angles[kk].Add(ray.CurrentDirection);
ray_strengths[kk].Add(ray.FadedPower(this.viz_rps.Map.MeterPixelRatio));
ray_taus[kk].Add(ray.GetLifeSpan(this.viz_rps.Map.MeterPixelRatio));
}
kk++;
}
double[] args = null;
switch (signal_type)
{
case Signal_Type.PSEUDO_DOPPLER:
//if (this.receivers.First().Value.Antenna.AntType != AntennaType.PSEUDO_DOPPLER)
// return null;
Antenna_PseudoDoppler ant = this.viz_rps.Map.receivers.First().Value.Antenna as Antenna_PseudoDoppler;
args = fg.PackArgs_PseudoDoppler(this.viz_rps.Map.receivers.First().Value.FrequencyLow, this.viz_rps.Map.receivers.First().Value.CenterFrequency,
this.viz_rps.Map.receivers.First().Value.SampleFrequency, ant.SwitchFrequency, ant.Radius, ant.AntennaNumber);
break;
}
signals[num - 1] = new MWNumericArray[ray_angles.GetLength(0)];
for (int i = 0; i < signals.Length; i++)
{
signals[num - 1][i] = new FingerprintGenerator().GenerateSignal_MW(signal_type, ray_angles[i].ToArray(), ray_strengths[i].ToArray(), ray_taus[i].ToArray(), sample_cnt, args);
}
}
return signals;
}
private void createMapGrid()
{
// Add walls to the grid
BoundingRectangle test = new BoundingRectangle(Vector2.Zero, gridLength / 2);
grid = new List<Wall>[(int)Math.Ceiling((Map.HEIGHT + 100) / gridLength), (int)Math.Ceiling((Map.WIDTH + 100) / gridLength)];
int y = grid.GetLength(0);
int x = grid.GetLength(1);
for (int i = 0; i != y; ++i)
{
for (int j = 0; j != x; ++j)
{
test.Update(new Vector2(j * test.Bounds.Height, i * test.Bounds.Width));
grid[i, j] = new List<Wall>();
// Check collision
for (int k = 0; k != map.walls.Count; ++k)
{
if (test.Collides(map.walls[k].BoundingRectangle))
{
grid[i, j].Add(map.walls[k]);
}
}
}
}
}
static void Main()
{
Console.SetIn(new StreamReader(Console.OpenStandardInput(8192)));
var input = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
// N
var numberOfPoints = input[0];
// M
var numberOfStreets = input[1];
// H
var numberOfHospitals = input[2];
// H numbers
var pointsHospitalInput = Console.ReadLine();
// M numbers
var streets = new int[numberOfStreets, 3];
for (int i = 0; i < numberOfStreets; i++)
{
var currentStreet = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
for (int j = 0, len = streets.GetLength(1); j < len; j++)
{
streets[i, j] = currentStreet[j];
}
}
Graph = new List<KeyValuePair<int, int>>[numberOfPoints + 1];
for (int i = 0; i < numberOfStreets; i++)
{
if (Graph[streets[i, 0]] == null)
{
Graph[streets[i, 0]] = new List<KeyValuePair<int, int>>();
}
if (Graph[streets[i, 1]] == null)
{
Graph[streets[i, 1]] = new List<KeyValuePair<int, int>>();
}
Graph[streets[i, 0]].Add(new KeyValuePair<int, int>(streets[i, 1], streets[i, 2]));
Graph[streets[i, 1]].Add(new KeyValuePair<int, int>(streets[i, 0], streets[i, 2]));
}
var minMoves = int.MaxValue;
for (int i = 0; i < numberOfHospitals; i++)
{
Distance = new int[Graph.GetLength(0)];
List<int> hospitals = new List<int>();
if (numberOfHospitals == 1)
{
hospitals.Add(int.Parse(pointsHospitalInput));
Dijkstra(Graph, hospitals[0]);
}
else
{
//Console.WriteLine(pointsHospitalInput.Length);
hospitals = pointsHospitalInput.Split(' ').Select(int.Parse).ToList();
Dijkstra(Graph, hospitals[i]);
}
foreach (var hospital in hospitals)
{
Distance[hospital] = 0;
}
int currentMinMoves = Distance.Sum();
if (currentMinMoves < minMoves)
{
minMoves = currentMinMoves;
}
}
Console.WriteLine(minMoves);
}
public void SetCarte(List<Tuile>[,] carte)
{
collisionCarte = new int[carte.GetLength(0), carte.GetLength(1)];
for (int x = 0; x < collisionCarte.GetLength(0); x++)
for (int y = 0; y < collisionCarte.GetLength(1); y++)
collisionCarte[y, x] = carte[y, x].Count;
}
private void InitTileArray(List<string>[,] charArray)
{
for (int x = 0; x < charArray.GetLength(0); x++)
{
for (int y = 0; y < charArray.GetLength(1); y++)
{
Vector2 positionSource = Vector2.Zero;
bool isCollision = false;
foreach(string tuileStr in charArray[y, x])
{
switch (tuileStr[0])
{
case 'a':
positionSource = new Vector2(0, 0);
break;
case 'b':
positionSource = new Vector2(1, 0);
isCollision = true;
break;
case 'c':
positionSource = new Vector2(2, 0);
break;
case 'd':
positionSource = new Vector2(3, 0);
break;
case 'e':
positionSource = new Vector2(4, 0);
break;
case 'f':
positionSource = new Vector2(5, 0);
break;
case 'g':
positionSource = new Vector2(6, 0);
break;
case 'h':
positionSource = new Vector2(7, 0);
break;
case 'i':
positionSource = new Vector2(8, 0);
break;
case 'j':
positionSource = new Vector2(9, 0);
break;
case 'k':
positionSource = new Vector2(10, 0);
break;
case 'l':
positionSource = new Vector2(11, 0);
break;
case 'm':
positionSource = new Vector2(12, 0);
break;
case 'n':
positionSource = new Vector2(13, 0);
break;
case 'o':
positionSource = new Vector2(14, 0);
break;
case 'p':
positionSource = new Vector2(15, 0);
break;
default: //('a')
positionSource = new Vector2(7, 0);
break;
}
tuileArray[x, y].Add(new Tuile(new Vector2(x, y), positionSource, isCollision, int.Parse(tuileStr.Substring(1, 2))));
}
}
}
}
/// <summary>
/// implements the recomputing utility function. figures out what the utility for n would be if n flipped its state
/// from its present state in S.
/// </summary>
/// <param name="BucketTable"></param>
/// <param name="Best"></param>
/// <param name="ChosenParent"></param>
/// <param name="SecP"></param>
/// <param name="S"></param>
/// <param name="n"></param>
/// <param name="L"></param>
/// <param name="BestRelation"></param>
/// <param name="W"></param>
/// <returns></returns>
public int ComputeUtility(List<UInt32>[][] BucketTable, List<UInt32>[] Best, UInt32[] param_ChosenParent, bool[] param_SecP, bool[] S, UInt32 n, int L, byte BestRelation, UInt16[] W)
{
if (L == 0)
return 0;//no utility for routing to itself
int UNTilda = 0;//utility for S with n's state flipped
Int32 CustomerTreeSize = 0;
Int32 CustomerWeightedTreeSize = 0;
Int32 PeerWeightedTreeSize = 0;
Int32 ProviderWeightedTreeSize = 0;
//DON'T LET US OVERWRITE THINGS; we can overwrite S and flip it back at the end.
ChosenParent = (UInt32[])param_ChosenParent.Clone();
SecP = (bool[])param_SecP.Clone();
S[n] = !S[n];//reverse n's state (we revert this before we return).
//update n's path. if it has options
if (Best[n].Count > 1)
{
if (S[n]) //n became secure it cares about security in picking its path
updateParentWorker(n, ref Best, ref S, ref SecP, ref ChosenParent);//, ref tieBreakSet);
else
{
//n became insecure; re-evaluate its path options from the set of all paths.
UInt32 newParent = Best[n][0];
ChosenParent[n] = newParent;
}
}
// if (S[n])//can only have secP if n is secure. (using an and so we revoke SecP for n flipping back.
SecP[n] = S[n]&SecP[ChosenParent[n]];
byte[] throughN = new byte[Constants._numASNs];
for (int i = 0; i < Constants._numASNs; i++)
throughN[i] = 0;//empty value.
for (int row = L + 1; row < BucketTable.GetLength(0); row++)
{
foreach (int col in columns)
{
if (BucketTable[row][col] == null)
continue;
foreach (UInt32 i in BucketTable[row][col])
{
/*only secure nodes will change their parents based on security. We still need to update
* whether or not they gothrough n though because someone before them may have changed to go
* through n*/
if (Best[i].Count > 1)//update path *only* if you have options.
updateParentWorker(i, ref Best, ref S, ref SecP, ref ChosenParent);//, ref tieBreakSet);
if (S[i])//only say your path is secure if you are secure
SecP[i] = SecP[ChosenParent[i]];
/* done updating our parents need to update whether we go through n or not */
if (row == L + 1 && ChosenParent[i] == n && col == Destination._PROVIDERCOLUMN)
throughN[i] = CustomerOf;//i is a customer of N
else if (row == L + 1 && ChosenParent[i] == n && col == Destination._PEERCOLUMN)
throughN[i] = PeerOf;
else if (row == L + 1 && ChosenParent[i] == n && col == Destination._CUSTOMERCOLUMN)
throughN[i] = ProviderTo;//i is a provider to N
else if (row > (L + 1))
throughN[i] = throughN[ChosenParent[i]];
//update utility values on how we pass through n
switch (throughN[i])
{
case CustomerOf:
CustomerTreeSize++;
CustomerWeightedTreeSize += W[i];
break;
case PeerOf:
PeerWeightedTreeSize += W[i];
break;
case ProviderTo:
ProviderWeightedTreeSize += W[i];
break;
}
}
}
}
S[n] = !S[n];//flip n back
UInt16 dWeight = W[BucketTable[0][ 0][0]];
UNTilda = SimulatorLibrary.utilityComputation(CustomerTreeSize,
CustomerWeightedTreeSize,
PeerWeightedTreeSize,
ProviderWeightedTreeSize,
BestRelation,dWeight);
return UNTilda;
}
/*
* Calculates and processes all collisions that occur,
* using the collision cell optimization structure
*/
public void Update(List<GameUnit> units, Level level)
{
cellGrid = ConstructCollisionGrid(units, level);
for (int ii = 0; ii < cellGrid.GetLength(0); ii++)
{
for (int jj = 0; jj < cellGrid.GetLength(1); jj++)
{
if (cellGrid[ii, jj] != null)
{
ProcessCollisions(jj, ii, level.Map);
}
}
}
}
private void BuildTiles()
{
tiles = new List<int>[roomHeight / 32 + 1, roomWidth / 32 + 1];
for (int i = 0; i < tiles.GetLength(0); i++)
for (int j = 0; j < tiles.GetLength(1); j++)
{
tiles[i, j] = new List<int>();
tiles[i, j].Add(-1);
}
// Fill each wall object with middle tiles
var realWalls = from Wall w in walls
where !(w is PlatformWall) && !(w is FloatingPlatform) && !(w is DeathWall) && !(w is Mirror)
select w;
foreach (Wall w in realWalls)
{
for (int x = w.Bounds.X; x < w.Bounds.Right; x += 32)
for (int y = w.Bounds.Y; y < w.Bounds.Bottom; y += 32)
if (x >= 0 && x <= roomWidth && y >= 0 && y <= roomHeight)
tiles[y / 32, x / 32].Insert(0, 4);
}
// Fill each death wall with death tile
var deathWalls = from Wall w in walls
where w is DeathWall
select w;
foreach (Wall w in deathWalls)
{
for (int x = w.Bounds.X; x < w.Bounds.Right; x += 32)
for (int y = w.Bounds.Y; y < w.Bounds.Bottom; y += 32)
if (x >= 0 && x <= roomWidth && y >= 0 && y <= roomHeight)
tiles[y / 32, x / 32].Insert(0, 9);
}
// Fill each mirror with mirror tile
var mirrors = from Wall w in walls
where w is Mirror
select w;
foreach (Wall w in mirrors)
{
for (int x = w.Bounds.X; x < w.Bounds.Right; x += 32)
for (int y = w.Bounds.Y; y < w.Bounds.Bottom; y += 32)
if (x >= 0 && x <= roomWidth && y >= 0 && y <= roomHeight)
tiles[y / 32, x / 32].Insert(0, 10);
}
int newHeight = roomHeight / 32;
int newWidth = roomWidth / 32;
// Find all corners and sides and attach corresponding tile
for (int x = 0; x <= newWidth; x++)
for (int y = 0; y <= newHeight; y++)
if (tiles[y, x].Count > 0 && tiles[y, x][0] == 4)
{
// Corners
if (x - 1 >= 0 && x - 1 <= newWidth && y - 1 >= 0 && y - 1 <= newHeight && tiles[y, x - 1][0] != 4 && tiles[y - 1, x - 1][0] != 4 && tiles[y - 1, x][0] != 4)
tiles[y - 1, x - 1].Add(0);
if (x - 1 >= 0 && x - 1 <= newWidth && y + 1 >= 0 && y + 1 <= newHeight && tiles[y, x - 1][0] != 4 && tiles[y + 1, x - 1][0] != 4 && tiles[y + 1, x][0] != 4)
tiles[y + 1, x - 1].Add(2);
if (x + 1 >= 0 && x + 1 <= newWidth && y - 1 >= 0 && y - 1 <= newHeight && tiles[y, x + 1][0] != 4 && tiles[y - 1, x + 1][0] != 4 && tiles[y - 1, x][0] != 4)
tiles[y - 1, x + 1].Add(6);
if (x + 1 >= 0 && x + 1 <= newWidth && y + 1 >= 0 && y + 1 <= newHeight && tiles[y, x + 1][0] != 4 && tiles[y + 1, x + 1][0] != 4 && tiles[y + 1, x][0] != 4)
tiles[y + 1, x + 1].Add(8);
// Sides
if (x - 1 >= 0 && x - 1 <= newWidth && tiles[y, x - 1][0] != 4)
tiles[y, x - 1].Add(1);
if (y - 1 >= 0 && y - 1 <= newHeight && tiles[y - 1, x][0] != 4)
tiles[y - 1, x].Add(3);
if (y + 1 >= 0 && y + 1 <= newHeight && tiles[y + 1, x][0] != 4)
tiles[y + 1, x].Add(5);
if (x + 1 >= 0 && x + 1 <= newWidth && tiles[y, x + 1][0] != 4)
tiles[y, x + 1].Add(7);
}
}
/// <summary>
/// calibrate stereo camera from the given images
/// </summary>
/// <param name="directory">directory containing the calibration images</param>
/// <param name="baseline_mm">baseline of the stereo camera</param>
/// <param name="dotdist_mm">horizontal distance to the centre of the calibration pattern in millimetres</param>
/// <param name="height_mm">vertical height of the cameras above the calibration pattern</param>
/// <param name="fov_degrees">field of view of the cameras in degrees</param>
/// <param name="dot_spacing_mm">spacing between dots on the calibration pattern in millimetres</param>
/// <param name="focal_length_pixels">focal length of the cameras in pixels</param>
/// <param name="file_extension">file extension of the calibration images (typically "jpg" or "bmp")</param>
public static void Calibrate(string directory,
int baseline_mm,
int dotdist_mm,
int height_mm,
float fov_degrees,
float dot_spacing_mm,
float focal_length_pixels,
string file_extension)
{
string calibration_xml_filename = "calibration.xml";
if (File.Exists(calibration_xml_filename))
File.Delete(calibration_xml_filename);
if (directory.Contains("\\"))
{
if (!directory.EndsWith("\\")) directory += "\\";
}
else
{
if (directory.Contains("/"))
if (!directory.EndsWith("/")) directory += "/";
}
string[] filename = Directory.GetFiles(directory, "*." + file_extension);
if (filename != null)
{
// two lists to store filenames for camera 0 and camera 1
List<string>[] image_filename = new List<string>[2];
image_filename[0] = new List<string>();
image_filename[1] = new List<string>();
// populate the lists
for (int i = 0; i < filename.Length; i++)
{
if (filename[i].Contains("raw0"))
image_filename[0].Add(filename[i]);
if (filename[i].Contains("raw1"))
image_filename[1].Add(filename[i]);
}
if (image_filename[0].Count == 0)
{
Console.WriteLine("Did not find any calibration files. Do they begin with raw0 or raw1 ?");
}
else
{
if (image_filename[0].Count != image_filename[1].Count)
{
Console.WriteLine("There must be the same number of images from camera 0 and camera 1");
}
else
{
string lens_distortion_image_filename = "temp_lens_distortion.jpg";
string curve_fit_image_filename = "temp_curve_fit.jpg";
string rectified_image_filename = "temp_rectified.jpg";
string[] lens_distortion_filename = { "lens_distortion0.jpg", "lens_distortion1.jpg" };
string[] curve_fit_filename = { "curve_fit0.jpg", "curve_fit1.jpg" };
string[] rectified_filename = { "rectified0.jpg", "rectified1.jpg" };
int img_width = 0, img_height = 0;
// distance to the centre dot
float dist_to_centre_dot_mm = (float)Math.Sqrt(dotdist_mm * dotdist_mm + height_mm * height_mm);
// find dots within the images
polynomial[] distortion_curve = new polynomial[2];
double[] centre_x = new double[2];
double[] centre_y = new double[2];
double[] scale_factor = new double[2];
double[] rotation = new double[2];
// unrectified position of the calibration dot (in image coordinates) for each image
List<List<double>> centre_dot_position = new List<List<double>>();
// pan/tilt mechanism servo positions
List<List<double>> pan_servo_position = new List<List<double>>();
List<List<double>> tilt_servo_position = new List<List<double>>();
List<int[]> calibration_map = new List<int[]>();
int[] winner_index = new int[2];
for (int cam = 0; cam < image_filename.GetLength(0); cam++)
{
// unrectified centre dot positions in image coordinates
centre_dot_position.Add(new List<double>());
centre_dot_position.Add(new List<double>());
// pan/tilt mechanism servo positions
pan_servo_position.Add(new List<double>());
tilt_servo_position.Add(new List<double>());
double minimum_error = double.MaxValue;
for (int i = 0; i < image_filename[cam].Count; i++)
{
// extract the pan and tilt servo positions of from the filename
double pan = 9999, tilt = 9999;
GetPanTilt(image_filename[cam][i], ref pan, ref tilt);
pan_servo_position[cam].Add(pan);
tilt_servo_position[cam].Add(tilt);
int random_seed = 0;
// detect the dots and calculate a best fit curve
double centre_of_distortion_x = 0;
double centre_of_distortion_y = 0;
polynomial lens_distortion_curve = null;
double camera_rotation = 0;
double scale = 0;
float dot_x = -1, dot_y = -1;
double min_err = double.MaxValue;
int[] calib_map = null;
hypergraph dots =
Detect(image_filename[cam][i],
ref img_width, ref img_height,
fov_degrees, dist_to_centre_dot_mm, dot_spacing_mm,
ref centre_of_distortion_x, ref centre_of_distortion_y,
ref lens_distortion_curve,
ref camera_rotation, ref scale,
lens_distortion_image_filename,
curve_fit_image_filename,
rectified_image_filename,
ref dot_x, ref dot_y,
ref min_err, ref calib_map,
random_seed);
centre_dot_position[cam].Add(dot_x);
centre_dot_position[cam].Add(dot_y);
if (lens_distortion_curve != null)
{
bool update = false;
if (distortion_curve[cam] == null)
{
update = true;
}
else
{
if (min_err < minimum_error)
update = true;
}
if (update)
{
minimum_error = min_err;
// record the result with the smallest RMS error
distortion_curve[cam] = lens_distortion_curve;
centre_x[cam] = centre_of_distortion_x;
centre_y[cam] = centre_of_distortion_y;
rotation[cam] = camera_rotation;
scale_factor[cam] = scale;
if (calibration_map.Count <= cam)
calibration_map.Add(calib_map);
else
calibration_map[cam] = calib_map;
winner_index[cam] = i;
if (File.Exists(lens_distortion_filename[cam])) File.Delete(lens_distortion_filename[cam]);
File.Copy(lens_distortion_image_filename, lens_distortion_filename[cam]);
if (File.Exists(curve_fit_filename[cam])) File.Delete(curve_fit_filename[cam]);
File.Copy(curve_fit_image_filename, curve_fit_filename[cam]);
if (File.Exists(rectified_filename[cam])) File.Delete(rectified_filename[cam]);
File.Copy(rectified_image_filename, rectified_filename[cam]);
}
}
}
}
// positions of the centre dots
List<List<double>> rectified_dots = new List<List<double>>();
for (int cam = 0; cam < image_filename.GetLength(0); cam++)
{
if (distortion_curve[cam] != null)
{
// position in the centre dots in the raw image
List<double> pts = new List<double>();
for (int i = 0; i < centre_dot_position[cam].Count; i += 2)
{
pts.Add(centre_dot_position[cam][i]);
pts.Add(centre_dot_position[cam][i + 1]);
}
// rectified positions for the centre dots
List<double> rectified_pts =
RectifyDots(pts, img_width, img_height,
distortion_curve[cam],
centre_x[cam], centre_y[cam],
rotation[cam], scale_factor[cam]);
rectified_dots.Add(rectified_pts);
}
}
ShowCentreDots(filename[winner_index[0]], rectified_dots, "centre_dots.jpg");
ShowCentreDots(filename[winner_index[0]], centre_dot_position, "centre_dots2.jpg");
if (calibration_map.Count == 2)
{
if ((calibration_map[0] != null) &&
(calibration_map[1] != null))
{
Rectify(image_filename[0][winner_index[0]], image_filename[1][winner_index[0]],
calibration_map[0], calibration_map[1], "Rectification2.jpg");
}
}
if (rectified_dots.Count > 1)
{
// calibrate the pan and tilt mechanism
polynomial pan_curve = null, tilt_curve = null;
float pan_offset_x = 0, pan_offset_y = 0;
float tilt_offset_x = 0, tilt_offset_y = 0;
CalibratePanTilt(pan_servo_position, tilt_servo_position,
rectified_dots, fov_degrees,
img_width, img_height,
dotdist_mm, height_mm,
ref pan_curve, ref pan_offset_x, ref pan_offset_y,
ref tilt_curve, ref tilt_offset_x, ref tilt_offset_y);
if (distortion_curve[0] != null)
{
// find the relative offset in the left and right images
double offset_x = 0;
double offset_y = 0;
bool is_valid = false;
if (distortion_curve[1] != null)
{
int index0 = winner_index[0] * 2;
int index1 = winner_index[1] * 2;
if ((rectified_dots[0].Count < index0 + 1) &&
(rectified_dots[1].Count < index1 + 1))
{
double x0 = rectified_dots[0][index0];
double y0 = rectified_dots[0][index0 + 1];
double x1 = rectified_dots[1][index1];
double y1 = rectified_dots[1][index1 + 1];
offset_x = x1 - x0;
offset_y = y1 - y0;
// calculate the focal length
if (focal_length_pixels < 1)
{
focal_length_pixels = GetFocalLengthFromDisparity((float)dist_to_centre_dot_mm, (float)baseline_mm, (float)offset_x);
Console.WriteLine("Calculated focal length (pixels): " + focal_length_pixels.ToString());
}
// subtract the expected disparity for the centre dot
float expected_centre_dot_disparity = GetDisparityFromDistance(focal_length_pixels, baseline_mm, dist_to_centre_dot_mm);
float check_dist_mm = GetDistanceFromDisparity(focal_length_pixels, baseline_mm, expected_centre_dot_disparity);
//Console.WriteLine("expected_centre_dot_disparity: " + expected_centre_dot_disparity.ToString());
//Console.WriteLine("observed disparity: " + offset_x.ToString());
offset_x -= expected_centre_dot_disparity;
is_valid = true;
}
}
if (is_valid)
{
// save the results as an XML file
Save(calibration_xml_filename, "Test", focal_length_pixels, baseline_mm, fov_degrees,
img_width, img_height, distortion_curve,
centre_x, centre_y, rotation, scale_factor,
lens_distortion_filename, curve_fit_filename,
(float)offset_x, (float)offset_y,
pan_curve, pan_offset_x, pan_offset_y,
tilt_curve, tilt_offset_x, tilt_offset_y);
}
}
}
}
}
}
else
{
Console.WriteLine("No calibration " + file_extension + " images were found");
}
}
public InputCatchData(float[] modelLats, float[] modelLons, float cellSize)
{
StreamReader r_ht = new StreamReader("input\\data\\Fisheries\\catchratesyr2000HT.csv");
StreamReader r = new StreamReader("input\\data\\Fisheries\\catchrateyr2000.csv");
//Read trait data
Traits = new FishTraits();
//Retrieve the Max Mass range from the trait data
var temp = Traits.MassRange();
double[] MaxMassRange = temp.Item1;
string[] MaxMassRangeSp = temp.Item2;
//Calculate a set of mass bins to be used for removing fisheries catches from binned Madingley biomasses
//TO DO: make these bins flexible and user defined
int MinMassbinMax = Convert.ToInt32(Math.Ceiling(Math.Log10(MaxMassRange[0])));
int MaxMassbinMax = Convert.ToInt32(Math.Ceiling(Math.Log10(MaxMassRange[1])));
int NumBins = (MaxMassbinMax - MinMassbinMax) + 1;
_MassBins = new double[NumBins];
for (int i = 0; i < NumBins - 1; i++)
{
_MassBins[i] = Math.Pow(10, MinMassbinMax + i);
}
_UnknownMassBinIndex = NumBins - 1;
string l;
char[] comma = ",".ToCharArray();
string[] f;
List<int> year_ht = new List<int>();
List<int> cell_ht = new List<int>();
List<double> catchRate_ht = new List<Double>();
List<string> taxa_ht = new List<string>();
List<int> year = new List<int>();
List<int> cell = new List<int>();
List<double> catchRate = new List<Double>();
List<string> taxa = new List<string>();
//Read the Higher Taxonomy file
while (!r_ht.EndOfStream)
{
l = r_ht.ReadLine();
// Split fields by commas
f = l.Split(comma);
// Lists of the different fields
year_ht.Add(Convert.ToInt32(f[0]));
cell_ht.Add(Convert.ToInt32(f[1]));
catchRate_ht.Add(Convert.ToDouble(f[2]));
taxa_ht.Add(f[3]);
}
//Read the species catch file
while (!r.EndOfStream)
{
l = r.ReadLine();
// Split fields by commas
f = l.Split(comma);
// Lists of the different fields
year.Add(Convert.ToInt32(f[0]));
cell.Add(Convert.ToInt32(f[1]));
catchRate.Add(Convert.ToDouble(f[2]));
taxa.Add(f[3]);
}
float MinLon = -179.75f;
float MaxLon = 179.75f;
float MaxLat = 89.75f;
float MinLat = -89.75f;
_CatchNumLats = (int)((MaxLat - MinLat) / 0.5) + 1;
_CatchNumLons = (int)((MaxLon - MinLon) / 0.5) + 1;
_CatchTotal = new double[_CatchNumLats, _CatchNumLons];
_CatchBinned = new double[_CatchNumLats, _CatchNumLons, NumBins];
UnknownTaxa = new List<string>[_CatchNumLats, _CatchNumLons];
for (int i = 0; i < UnknownTaxa.GetLength(0); i++)
{
for (int j = 0; j < UnknownTaxa.GetLength(1); j++)
{
UnknownTaxa[i, j] = new List<string>();
}
}
_CatchLats = new float[_CatchNumLats];
_CatchLons = new float[_CatchNumLons];
int[] Index;
// Match lon index to lon
for (int i = 0; i < _CatchNumLons; i++)
{
_CatchLons[i] = MinLon + (i * 0.5f);
}
// Match lat index to lat
for (int i = 0; i < _CatchNumLats; i++)
{
_CatchLats[i] = MaxLat - (i * 0.5f);
}
//Will hold the mass bin index for the catch data
int mb = 0;
//Allocate the species level catch to cells and mass bins
for (int i = 0; i < catchRate.Count; i++)
{
Index = IndexLookup(cell[i]);
//Need to convert to size bins
mb = AssignCatchToMassBin(taxa[i]);
_CatchTotal[Index[0], Index[1]] += catchRate[i] * 1E6;
_CatchBinned[Index[0], Index[1], mb] += catchRate[i] * 1E6;
//If the taxa does not have trait data then list this taxa
if (mb == UnknownMassBinIndex) UnknownTaxa[Index[0], Index[1]].Add(taxa[i]);
}
//Allocate the higher taxa level catch to cells and mass bins
for (int i = 0; i < catchRate_ht.Count; i++)
{
Index = IndexLookup(cell_ht[i]);
//Need to convert to size bins
mb = AssignCatchToMassBin(taxa_ht[i]);
_CatchTotal[Index[0], Index[1]] += catchRate_ht[i] * 1E6;
_CatchBinned[Index[0], Index[1], mb] += catchRate_ht[i] * 1E6;
//If the taxa does not have trait data then list this taxa
if (mb == UnknownMassBinIndex) UnknownTaxa[Index[0], Index[1]].Add(taxa_ht[i]);
}
//foreach (var u in UnknownTaxa)
//{
// if (u.Count > 0.0) Console.WriteLine(u.Count);
//}
double CumulativeCatch = 0.0;
for (int i = 0; i < _CatchTotal.GetLength(0); i++)
{
for (int j = 0; j < _CatchTotal.GetLength(1); j++)
{
CumulativeCatch += _CatchTotal[i, j];
}
}
Console.WriteLine(CumulativeCatch);
AggregateCatchData(modelLats, modelLons, cellSize);
}
