/// <summary> /// finds the interception points between grid lines /// </summary> private void poltLineIntercepts() { if (line != null) { // create an array to store the line intercepts int intercepts_x = line[0].Count / 4; int intercepts_y = line[1].Count / 4; line_intercepts = new float[intercepts_x, intercepts_y, 2]; for (int i = 0; i < line[0].Count; i += 4) { // get the first line coordinates ArrayList lines0 = line[0]; float x0 = (float)lines0[i]; float y0 = (float)lines0[i + 1]; float x1 = (float)lines0[i + 2]; float y1 = (float)lines0[i + 3]; for (int j = 0; j < line[1].Count; j += 4) { // get the second line coordinates ArrayList lines1 = line[1]; float x2 = (float)lines1[j]; float y2 = (float)lines1[j + 1]; float x3 = (float)lines1[j + 2]; float y3 = (float)lines1[j + 3]; // find the interception between the two lines float ix = 0, iy = 0; geometry.intersection(x0, y0, x1, y1, x2, y2, x3, y3, ref ix, ref iy); // store the intercept position line_intercepts[i / 4, j / 4, 0] = ix; line_intercepts[i / 4, j / 4, 1] = iy; } } // update the perimeter border_perimeter = new polygon2D(); float xx = line_intercepts[0, 0, 0]; float yy = line_intercepts[0, 0, 1]; border_perimeter.Add(xx, yy); xx = line_intercepts[intercepts_x - 1, 0, 0]; yy = line_intercepts[intercepts_x - 1, 0, 1]; border_perimeter.Add(xx, yy); xx = line_intercepts[intercepts_x - 1, intercepts_y - 1, 0]; yy = line_intercepts[intercepts_x - 1, intercepts_y - 1, 1]; border_perimeter.Add(xx, yy); xx = line_intercepts[0, intercepts_y - 1, 0]; yy = line_intercepts[0, intercepts_y - 1, 1]; border_perimeter.Add(xx, yy); } }
/// <summary> /// simple function used to test grid creation /// </summary> /// <param name="filename">filename of the test image to be created</param> public static void Test(string filename) { int image_width = 640; int image_height = 480; int dimension_x = 10; int dimension_y = 10; Bitmap bmp = new Bitmap(image_width, image_height, System.Drawing.Imaging.PixelFormat.Format24bppRgb); byte[] img = new byte[image_width * image_height * 3]; polygon2D test_poly; grid2D grid; test_poly = new polygon2D(); test_poly.Add(image_width * 15 / 100, image_height * 20 / 100); test_poly.Add(image_width * 40 / 100, image_height * 20 / 100); test_poly.Add(image_width * 40 / 100, image_height * 40 / 100); test_poly.Add(image_width * 15 / 100, image_height * 40 / 100); grid = new grid2D(dimension_x, dimension_y, test_poly, 0, false); grid.ShowLines(img, image_width, image_height, 0, 255, 0, 0); int half_width = image_width / 2; test_poly = new polygon2D(); test_poly.Add(half_width + (image_width * 20 / 100), image_height * 20 / 100); test_poly.Add(half_width + (image_width * 35 / 100), image_height * 20 / 100); test_poly.Add(half_width + (image_width * 40 / 100), image_height * 40 / 100); test_poly.Add(half_width + (image_width * 15 / 100), image_height * 40 / 100); grid = new grid2D(dimension_x, dimension_y, test_poly, 0, false); grid.ShowLines(img, image_width, image_height, 0, 255, 0, 0); int half_height = image_height / 2; test_poly = new polygon2D(); test_poly.Add(image_width * 15 / 100, half_height + (image_height * 24 / 100)); test_poly.Add(image_width * 40 / 100, half_height + (image_height * 20 / 100)); test_poly.Add(image_width * 40 / 100, half_height + (image_height * 40 / 100)); test_poly.Add(image_width * 15 / 100, half_height + (image_height * 36 / 100)); grid = new grid2D(dimension_x, dimension_y, test_poly, 0, false); grid.ShowLines(img, image_width, image_height, 0, 255, 0, 0); test_poly = new polygon2D(); test_poly.Add(half_width + (image_width * 20 / 100), half_height + (image_height * 24 / 100)); test_poly.Add(half_width + (image_width * 35 / 100), half_height + (image_height * 20 / 100)); test_poly.Add(half_width + (image_width * 40 / 100), half_height + (image_height * 40 / 100)); test_poly.Add(half_width + (image_width * 15 / 100), half_height + (image_height * 36 / 100)); grid = new grid2D(dimension_x, dimension_y, test_poly, 0, false); grid.ShowLines(img, image_width, image_height, 0, 255, 0, 0); BitmapArrayConversions.updatebitmap_unsafe(img, bmp); bmp.Save(filename); }
private void Snake(bool[,] binary_image, bool BlackOnWhite, int max_itterations, Random rnd) { bool SnakeComplete = false; //set the initial parameters for the snake prevSnakeStationaryPoints = 0; snakeStationary = 0; // itterate until the snake can get no smaller int i = 0; while ((!SnakeComplete) && (i < max_itterations)) { SnakeComplete = Update(binary_image, BlackOnWhite, elasticity, gravity, rnd); i++; } // create a new polygon shape shape = new polygon2D(); for (i = 0; i < no_of_points; i++) { shape.Add((int)SnakePoint[i, SNAKE_X], (int)SnakePoint[i, SNAKE_Y]); } }
/// <summary> /// creates a circle shape /// </summary> /// <param name="centre_x"> /// centre x coordinate of the circle <see cref="System.Single"/> /// </param> /// <param name="centre_y"> /// centre y coordinate of the circle <see cref="System.Single"/> /// </param> /// <param name="radius"> /// radius of the circle <see cref="System.Single"/> /// </param> /// <param name="circumference_steps"> /// number of steps to use when drawing the circle <see cref="System.Int32"/> /// </param> /// <returns> /// polygon representing a circle <see cref="polygon2D"/> /// </returns> public static polygon2D CreateCircle(float centre_x, float centre_y, float radius, int circumference_steps) { polygon2D circle = new polygon2D(); for (int i = 0; i < circumference_steps; i++) { float angle = i * (float)Math.PI * 2 / circumference_steps; float x = centre_x + (radius * (float)Math.Sin(angle)); float y = centre_y + (radius * (float)Math.Cos(angle)); circle.Add(x, y); } return(circle); }
/// <summary> /// detects a square around the centre dot on the calibration pattern /// </summary> /// <param name="dots">detected dots</param> /// <param name="centredots">returned dots belonging to the centre square</param> /// <returns>centre square</returns> private static polygon2D GetCentreSquare(hypergraph dots, ref List<CalibrationDot> centredots) { centredots = new List<CalibrationDot>(); // find the centre dot CalibrationDot centre = null; int i = 0; while ((i < dots.Nodes.Count) && (centre == null)) { CalibrationDot dot = (CalibrationDot)dots.Nodes[i]; if (dot.centre) centre = dot; i++; } // look for the four surrounding dots List<CalibrationDot> centre_dots = new List<CalibrationDot>(); List<double> distances = new List<double>(); i = 0; for (i = 0; i < dots.Nodes.Count; i++) { CalibrationDot dot = (CalibrationDot)dots.Nodes[i]; if (!dot.centre) { double dx = dot.x - centre.x; double dy = dot.y - centre.y; double dist = Math.Sqrt(dx * dx + dy * dy); if (distances.Count == 4) { int index = -1; double max_dist = 0; for (int j = 0; j < 4; j++) { if (distances[j] > max_dist) { index = j; max_dist = distances[j]; } } if (dist < max_dist) { distances[index] = dist; centre_dots[index] = dot; } } else { distances.Add(dist); centre_dots.Add(dot); } } } polygon2D centre_square = null; if (centre_dots.Count == 4) { centre_square = new polygon2D(); for (i = 0; i < 4; i++) centre_square.Add(0, 0); double xx = centre.x; double yy = centre.y; int index = 0; for (i = 0; i < 4; i++) { if ((centre_dots[i].x < xx) && (centre_dots[i].y < yy)) { xx = centre_dots[i].x; yy = centre_dots[i].y; centre_square.x_points[0] = (float)xx; centre_square.y_points[0] = (float)yy; index = i; } } centredots.Add(centre_dots[index]); xx = centre.x; yy = centre.y; for (i = 0; i < 4; i++) { if ((centre_dots[i].x > xx) && (centre_dots[i].y < yy)) { xx = centre_dots[i].x; yy = centre_dots[i].y; centre_square.x_points[1] = (float)xx; centre_square.y_points[1] = (float)yy; index = i; } } centredots.Add(centre_dots[index]); xx = centre.x; yy = centre.y; for (i = 0; i < 4; i++) { if ((centre_dots[i].x > xx) && (centre_dots[i].y > yy)) { xx = centre_dots[i].x; yy = centre_dots[i].y; centre_square.x_points[2] = (float)xx; centre_square.y_points[2] = (float)yy; index = i; } } centredots.Add(centre_dots[index]); xx = centre.x; yy = centre.y; for (i = 0; i < 4; i++) { if ((centre_dots[i].x < xx) && (centre_dots[i].y > yy)) { xx = centre_dots[i].x; yy = centre_dots[i].y; centre_square.x_points[3] = (float)xx; centre_square.y_points[3] = (float)yy; index = i; } } centredots.Add(centre_dots[index]); } return (centre_square); }
/// <summary> /// returns an ideally spaced grid over the actual detected spots /// </summary> /// <param name="grid"></param> /// <returns></returns> private static grid2D OverlayIdealGrid(CalibrationDot[,] grid, List<CalibrationDot> corners, ref int grid_offset_x, ref int grid_offset_y, int random_seed) { grid2D overlay_grid = null; int grid_tx = -1; int grid_ty = -1; int grid_bx = -1; int grid_by = -1; int offset_x = 0; int offset_y = 0; bool found = false; int max_region_area = 0; // try searching horizontally and vertically // then pick the result with the greatest area for (int test_orientation = 0; test_orientation < 2; test_orientation++) { bool temp_found = false; int temp_grid_tx = -1; int temp_grid_ty = -1; int temp_grid_bx = -1; int temp_grid_by = -1; int temp_offset_x = 0; int temp_offset_y = 0; switch (test_orientation) { case 0: { while ((temp_offset_y < 5) && (!temp_found)) { temp_offset_x = 0; while ((temp_offset_x < 3) && (!temp_found)) { temp_grid_tx = temp_offset_x; temp_grid_ty = temp_offset_y; temp_grid_bx = grid.GetLength(0) - 1 - temp_offset_x; temp_grid_by = grid.GetLength(1) - 1 - temp_offset_y; if ((temp_grid_bx < grid.GetLength(0)) && (temp_grid_tx < grid.GetLength(0)) && (temp_grid_by < grid.GetLength(1)) && (temp_grid_ty < grid.GetLength(1)) && (temp_grid_ty >= 0) && (temp_grid_by >= 0) && (temp_grid_tx >= 0) && (temp_grid_bx >= 0)) { if ((grid[temp_grid_tx, temp_grid_ty] != null) && (grid[temp_grid_bx, temp_grid_ty] != null) && (grid[temp_grid_bx, temp_grid_by] != null) && (grid[temp_grid_tx, temp_grid_by] != null)) { temp_found = true; } } temp_offset_x++; } temp_offset_y++; } break; } case 1: { while ((temp_offset_x < 3) && (!temp_found)) { temp_offset_y = 0; while ((temp_offset_y < 5) && (!temp_found)) { temp_grid_tx = temp_offset_x; temp_grid_ty = temp_offset_y; temp_grid_bx = grid.GetLength(0) - 1 - temp_offset_x; temp_grid_by = grid.GetLength(1) - 1 - temp_offset_y; if ((temp_grid_bx < grid.GetLength(0)) && (temp_grid_tx < grid.GetLength(0)) && (temp_grid_by < grid.GetLength(1)) && (temp_grid_ty < grid.GetLength(1)) && (temp_grid_ty >= 0) && (temp_grid_by >= 0) && (temp_grid_tx >= 0) && (temp_grid_bx >= 0)) { if ((grid[temp_grid_tx, temp_grid_ty] != null) && (grid[temp_grid_bx, temp_grid_ty] != null) && (grid[temp_grid_bx, temp_grid_by] != null) && (grid[temp_grid_tx, temp_grid_by] != null)) { temp_found = true; } } temp_offset_y++; } temp_offset_x++; } break; } } temp_offset_y = temp_grid_ty - 1; while (temp_offset_y >= 0) { if ((temp_offset_y < grid.GetLength(1)) && (temp_offset_y >= 0)) { if ((grid[temp_grid_tx, temp_offset_y] != null) && (grid[temp_grid_bx, temp_offset_y] != null)) { temp_grid_ty = temp_offset_y; temp_offset_y--; } else break; } else break; } temp_offset_y = temp_grid_by + 1; while (temp_offset_y < grid.GetLength(1)) { if ((temp_offset_y < grid.GetLength(1)) && (temp_offset_y >= 0)) { if ((grid[temp_grid_tx, temp_offset_y] != null) && (grid[temp_grid_bx, temp_offset_y] != null)) { temp_grid_by = temp_offset_y; temp_offset_y++; } else break; } else break; } if (temp_found) { int region_area = (temp_grid_bx - temp_grid_tx) * (temp_grid_by - temp_grid_ty); if (region_area > max_region_area) { max_region_area = region_area; found = true; grid_tx = temp_grid_tx; grid_ty = temp_grid_ty; grid_bx = temp_grid_bx; grid_by = temp_grid_by; offset_x = temp_offset_x; offset_y = temp_offset_y; } } } if (found) { // record the positions of the corners corners.Add(grid[grid_tx, grid_ty]); corners.Add(grid[grid_bx, grid_ty]); corners.Add(grid[grid_bx, grid_by]); corners.Add(grid[grid_tx, grid_by]); double dx, dy; double x0 = grid[grid_tx, grid_ty].x; double y0 = grid[grid_tx, grid_ty].y; double x1 = grid[grid_bx, grid_ty].x; double y1 = grid[grid_bx, grid_ty].y; double x2 = grid[grid_tx, grid_by].x; double y2 = grid[grid_tx, grid_by].y; double x3 = grid[grid_bx, grid_by].x; double y3 = grid[grid_bx, grid_by].y; polygon2D perimeter = new polygon2D(); perimeter.Add((float)x0, (float)y0); perimeter.Add((float)x1, (float)y1); perimeter.Add((float)x3, (float)y3); perimeter.Add((float)x2, (float)y2); int grid_width = grid_bx - grid_tx; int grid_height = grid_by - grid_ty; int min_hits = 0; double min_dx = 0, min_dy = 0; // try various perimeter sizes double min_dist = double.MaxValue; int max_perim_size_tries = 100; polygon2D best_perimeter = perimeter; Random rnd = new Random(random_seed); for (int perim_size = 0; perim_size < max_perim_size_tries; perim_size++) { // try a small range of translations for (int nudge_x = -10; nudge_x <= 10; nudge_x++) { for (int nudge_y = -5; nudge_y <= 5; nudge_y++) { // create a perimeter at this scale and translation polygon2D temp_perimeter = perimeter.Scale(1.0f + (perim_size * 0.1f / max_perim_size_tries)); temp_perimeter = temp_perimeter.ScaleSideLength(0, 0.95f + ((float)rnd.NextDouble() * 0.1f)); temp_perimeter = temp_perimeter.ScaleSideLength(2, 0.95f + ((float)rnd.NextDouble() * 0.1f)); for (int i = 0; i < temp_perimeter.x_points.Count; i++) { temp_perimeter.x_points[i] += nudge_x; temp_perimeter.y_points[i] += nudge_y; } // create a grid based upon the perimeter grid2D temp_overlay_grid = new grid2D(grid_width, grid_height, temp_perimeter, 0, false); // how closely does the grid fit the actual observations ? double temp_min_dist = min_dist; BestFit(grid_tx, grid_ty, grid, temp_overlay_grid, ref min_dist, ref min_dx, ref min_dy, ref min_hits, ref grid_offset_x, ref grid_offset_y); // record the closest fit if (temp_min_dist < min_dist) { best_perimeter = temp_perimeter; overlay_grid = temp_overlay_grid; } } } } if (min_hits > 0) { dx = min_dx; dy = min_dy; Console.WriteLine("dx: " + dx.ToString()); Console.WriteLine("dy: " + dy.ToString()); x0 += dx; y0 += dy; x1 += dx; y1 += dy; x2 += dx; y2 += dy; x3 += dx; y3 += dy; perimeter = new polygon2D(); perimeter.Add((float)x0, (float)y0); perimeter.Add((float)x1, (float)y1); perimeter.Add((float)x3, (float)y3); perimeter.Add((float)x2, (float)y2); overlay_grid = new grid2D(grid_width, grid_height, perimeter, 0, false); } } return (overlay_grid); }
/// <summary> /// finds the interception points between grid lines /// </summary> private void poltLineIntercepts() { if (line != null) { // create an array to store the line intercepts int intercepts_x = line[0].Count/4; int intercepts_y = line[1].Count/4; line_intercepts = new float[intercepts_x, intercepts_y, 2]; for (int i = 0; i < line[0].Count; i += 4) { // get the first line coordinates ArrayList lines0 = line[0]; float x0 = (float)lines0[i]; float y0 = (float)lines0[i + 1]; float x1 = (float)lines0[i + 2]; float y1 = (float)lines0[i + 3]; for (int j = 0; j < line[1].Count; j += 4) { // get the second line coordinates ArrayList lines1 = line[1]; float x2 = (float)lines1[j]; float y2 = (float)lines1[j + 1]; float x3 = (float)lines1[j + 2]; float y3 = (float)lines1[j + 3]; // find the interception between the two lines float ix = 0, iy = 0; geometry.intersection(x0, y0, x1, y1, x2, y2, x3, y3, ref ix, ref iy); // store the intercept position line_intercepts[i/4, j/4, 0] = ix; line_intercepts[i/4, j/4, 1] = iy; } } // update the perimeter border_perimeter = new polygon2D(); float xx = line_intercepts[0, 0, 0]; float yy = line_intercepts[0, 0, 1]; border_perimeter.Add(xx, yy); xx = line_intercepts[intercepts_x - 1, 0, 0]; yy = line_intercepts[intercepts_x - 1, 0, 1]; border_perimeter.Add(xx, yy); xx = line_intercepts[intercepts_x - 1, intercepts_y - 1, 0]; yy = line_intercepts[intercepts_x - 1, intercepts_y - 1, 1]; border_perimeter.Add(xx, yy); xx = line_intercepts[0, intercepts_y - 1, 0]; yy = line_intercepts[0, intercepts_y - 1, 1]; border_perimeter.Add(xx, yy); } }
/// <summary> /// constructor /// </summary> /// <param name="dimension_x">number of cells across the grid</param> /// <param name="dimension_y">number of cells down the grid</param> /// <param name="cx">centre of the grid</param> /// <param name="cy">centre of the grid</param> /// <param name="orientation">orientation of the grid in radians</param> /// <param name="average_spacing_x">grid spacing in the x axis</param> /// <param name="average_spacing_y">grid spacing in the y axis</param> /// <param name="phase_offset_x">phase offset in the x axis</param> /// <param name="phase_offset_y">phase offset in the y axis</param> /// <param name="border_cells">number of cells to use as a border around the grid</param> public grid2D(int dimension_x, int dimension_y, float cx, float cy, float orientation, float average_spacing_x, float average_spacing_y, float phase_offset_x, float phase_offset_y, int border_cells, bool orientation_simple) { // create a perimeter region polygon2D perimeter = new polygon2D(); float length_x = average_spacing_x * dimension_x; float length_y = average_spacing_y * dimension_y; float half_length_x = length_x / 2; float half_length_y = length_y / 2; // adjust for phase cx += (average_spacing_x * phase_offset_x / (2 * (float)Math.PI)) * (float)Math.Sin(orientation); cy -= (average_spacing_y * phase_offset_y / (2 * (float)Math.PI)) * (float)Math.Cos(orientation); // find the mid point of the top line float px1 = cx + (half_length_y * (float)Math.Sin(orientation)); float py1 = cy + (half_length_y * (float)Math.Cos(orientation)); // find the top left vertex float x0 = px1 + (half_length_x * (float)Math.Sin(orientation - (float)(Math.PI / 2))); float y0 = py1 + (half_length_x * (float)Math.Cos(orientation - (float)(Math.PI / 2))); // find the top right vertex float x1 = px1 + (half_length_x * (float)Math.Sin(orientation + (float)(Math.PI / 2))); float y1 = py1 + (half_length_x * (float)Math.Cos(orientation + (float)(Math.PI / 2))); // find the bottom vertices by mirroring around the centre float x2 = cx + (cx - x0); float y2 = cy + (cy - y0); float x3 = cx - (x1 - cx); float y3 = cy - (y1 - cy); // update polygon with the perimeter vertices perimeter.Add(x0, y0); perimeter.Add(x1, y1); perimeter.Add(x2, y2); perimeter.Add(x3, y3); int dim_x = dimension_x; int dim_y = dimension_y; float first_side_length = perimeter.getSideLength(0); float second_side_length = perimeter.getSideLength(1); if (((dimension_x > dimension_y + 2) && (second_side_length > first_side_length)) || ((dimension_y > dimension_x + 2) && (first_side_length > second_side_length))) { dim_x = dimension_y; dim_y = dimension_x; } // initialise using this perimeter init(dim_x, dim_y, perimeter, border_cells, orientation_simple); }
/// <summary> /// returns an ideal grid with perfectly regular spacing /// </summary> /// <param name="grid"></param> /// <param name="image_width"></param> /// <param name="image_height"></param> /// <returns> /// </returns> private static grid2D GetIdealGrid(CalibrationDot[,] grid, int image_width, int image_height) { grid2D ideal_grid = null; float ideal_spacing = 0; double centre_x = image_width / 2; double centre_y = image_height / 2; double min_dist = double.MaxValue; int grid_cx=0, grid_cy=0; for (int x = 0; x < grid.GetLength(0); x++) { for (int y = 0; y < grid.GetLength(1); y++) { if (grid[x, y] != null) { double dx = grid[x, y].x - centre_x; double dy = grid[x, y].y - centre_y; double dist = dx*dx + dy*dy; if (dist < min_dist) { min_dist = dist; grid_cx = x; grid_cy = y; } } } } if (grid_cx > 0) { int[] orientation_histogram = new int[361]; List<double>[] orientations = new List<double>[361]; double average_dist = 0; int hits = 0; int local_search = 2; for (int x = grid_cx - local_search; x <= grid_cx + local_search; x++) { if ((x >= 0) && (x < grid.GetLength(0)-1)) { for (int y = grid_cy - local_search; y <= grid_cy + local_search; y++) { if ((y >= 1) && (y < grid.GetLength(1)-1)) { if (grid[x, y] != null) { for (int i = 0; i < grid[x, y].Links.Count; i++) { CalibrationLink link = (CalibrationLink)grid[x, y].Links[i]; CalibrationDot from_dot = (CalibrationDot)link.From; double dx = grid[x, y].x - from_dot.x; double dy = grid[x, y].y - from_dot.y; double dist = Math.Sqrt(dx*dx + dy*dy); if (dist > 0) { double orientation = Math.Asin(dx / dist); if (orientation < 0) orientation += Math.PI; if (dy < 0) orientation = (Math.PI * 2) - orientation; orientation = orientation / Math.PI * 180; int bucket = (int)orientation; orientation_histogram[bucket]++; if (orientations[bucket] == null) orientations[bucket] = new List<double>(); orientations[bucket].Add(orientation); average_dist += Math.Sqrt(dx*dx + dy*dy); hits++; } } } } } } } if (hits > 0) average_dist = average_dist / hits; ideal_spacing = (float)average_dist; int max_orientation_response = 0; int best_ang = 0; for (int ang = 0; ang < 90; ang++) { int response = orientation_histogram[ang] + orientation_histogram[ang + 90] + orientation_histogram[ang + 180]; if (response > max_orientation_response) { max_orientation_response = response; best_ang = ang; } } double average_orientation = 0; hits = 0; for (int offset = 0; offset < 3; offset++) { if (orientations[best_ang + offset] != null) { for (int ang = 0; ang < orientations[best_ang + offset].Count; ang++) { average_orientation += orientations[best_ang + offset][ang] - (Math.PI*offset/2); hits++; } } } if (hits > 0) { average_orientation /= hits; float pattern_orientation = (float)average_orientation; float offset_x = (float)grid[grid_cx, grid_cy].x; float offset_y = (float)grid[grid_cx, grid_cy].y; float r = ideal_spacing * dots_across; polygon2D perimeter = new polygon2D(); perimeter.Add(-r + offset_x, -r + offset_y); perimeter.Add(r + offset_x, -r + offset_y); perimeter.Add(r + offset_x, r + offset_y); perimeter.Add(-r + offset_x, r + offset_y); perimeter.rotate((float)average_orientation / 180 * (float)Math.PI, offset_x, offset_y); ideal_grid = new grid2D(dots_across*2, dots_across*2, perimeter, 0, false); int grid_width = grid.GetLength(0); int grid_height = grid.GetLength(1); int idx = 0; int xx=0, yy=0; float ideal_x, ideal_y; for (int orient = 0; orient < 8; orient++) { for (int x = 0; x < grid_width; x++) { for (int y = 0; y < grid_height; y++) { if (grid[x, y] != null) { switch(orient) { case 0: { xx = (x - grid_cx) + dots_across; yy = (y - grid_cy) + dots_across; break; } case 1: { xx = (x - grid_cx) + dots_across; yy = (grid_cy - y) + dots_across; break; } case 2: { xx = (grid_cx - x) + dots_across; yy = (y - grid_cy) + dots_across; break; } case 3: { xx = (grid_cx - x) + dots_across; yy = (grid_cy - y) + dots_across; break; } case 4: { xx = (y - grid_cy) + dots_across; yy = (x - grid_cx) + dots_across; break; } case 5: { xx = (y - grid_cy) + dots_across; yy = (grid_cx - x) + dots_across; break; } case 6: { xx = (grid_cy - y) + dots_across; yy = (x - grid_cx) + dots_across; break; } case 7: { xx = (grid_cy - y) + dots_across; yy = (grid_cx - x) + dots_across; break; } } if ((xx >= 0) && (xx < ideal_grid.cell.Length) && (yy >= 0) && (yy < ideal_grid.cell[0].Length)) { ideal_x = ideal_grid.cell[xx][yy].perimeter.x_points[idx]; ideal_y = ideal_grid.cell[xx][yy].perimeter.y_points[idx]; if (orient == 0) { grid[x, y].rectified_x = ideal_x; grid[x, y].rectified_y = ideal_y; } else { double diff_x1 = grid[x, y].rectified_x - grid[x, y].x; double diff_y1 = grid[x, y].rectified_y - grid[x, y].y; double dist1 = diff_x1*diff_x1 + diff_y1*diff_y1; double diff_x2 = ideal_x - grid[x, y].x; double diff_y2 = ideal_y - grid[x, y].y; double dist2 = diff_x2*diff_x2 + diff_y2*diff_y2; if (dist2 < dist1) { grid[x, y].rectified_x = ideal_x; grid[x, y].rectified_y = ideal_y; } } } } } } } } } return(ideal_grid); }
/// <summary> /// returns a copy of the polygon /// </summary> /// <returns></returns> public polygon2D Copy() { polygon2D new_poly = new polygon2D(); new_poly.name = name; new_poly.type = type; new_poly.occupied = occupied; if (x_points != null) { for (int i = 0; i < x_points.Count; i++) { float x = x_points[i]; float y = y_points[i]; new_poly.Add(x, y); } } return (new_poly); }
/// <summary> /// scale the polygon to a new image size /// </summary> /// <param name="original_image_width"></param> /// <param name="original_image_height"></param> /// <param name="new_image_width"></param> /// <param name="new_image_height"></param> /// <returns></returns> public polygon2D Scale(int original_image_width, int original_image_height, int new_image_width, int new_image_height) { polygon2D rescaled = new polygon2D(); for (int i = 0; i < x_points.Count; i++) { float x = x_points[i] * new_image_width / original_image_width; float y = y_points[i] * new_image_height / original_image_height; rescaled.Add(x, y); } return (rescaled); }
/// <summary> /// return a scaled version of the polygon /// </summary> /// <param name="factor"></param> /// <returns></returns> public polygon2D Scale(float factor) { polygon2D rescaled = new polygon2D(); float centre_x = 0, centre_y = 0; getCentreOfGravity(ref centre_x, ref centre_y); for (int i = 0; i < x_points.Count; i++) { float dx = x_points[i] - centre_x; float dy = y_points[i] - centre_y; float x = (float)(centre_x + (dx * factor)); float y = (float)(centre_y + (dy * factor)); rescaled.Add(x, y); } return (rescaled); }
/// <summary> /// snaps the vertices of the polygon to a grid having the given spacing /// </summary> /// <param name="grid_spacing">spacing of the grid</param> /// <returns>fitted polygon</returns> public polygon2D SnapToGrid(float grid_spacing) { polygon2D result = new polygon2D(); if (x_points != null) { for (int i = 0; i < x_points.Count; i++) { float x = x_points[i] / grid_spacing; x = (float)Math.Round(x) * grid_spacing; float y = y_points[i] / grid_spacing; y = (float)Math.Round(y) * grid_spacing; result.Add(x, y); } } return (result);
/// <summary> /// returns a copy of this polygon with each vetex randomly perturbed /// </summary> /// <param name="max_displacement"> /// maximum perturbation <see cref="System.Single"/> /// </param> /// <param name="rnd"> /// random number generator <see cref="Random"/> /// </param> /// <returns> /// polygon object <see cref="polygon2D"/> /// </returns> public polygon2D Jiggle(float max_displacement, Random rnd) { polygon2D result = null; if (x_points != null) { result = new polygon2D(); float max = max_displacement*2; for (int i = 0; i < x_points.Count; i++) { float jiggled_x = x_points[i] + ((float)rnd.NextDouble() * max) - max_displacement; float jiggled_y = x_points[i] + ((float)rnd.NextDouble() * max) - max_displacement; result.Add(jiggled_x, jiggled_y); } } return(result); }