2

I've Googled and found zero answers for "safety wall", so I'm pretty sure that's not the correct term. I'll explain myself:

As I've read, I'm talking about taking a two dimensional array and placing it in a same array with an addition of one cell to each side to make sure staying safe and not getting out the limits I've created.

What is the right term for this technique and how would I use it?

Kevin Panko
  • 8,356
  • 19
  • 50
  • 61
Kesem David
  • 17
  • 1

2 Answers2

0

Like others told, you need to search it "sentinel" or something like "sentinel control"..

You can use sentinel control when you dont know size or limits of your program. For example, you are writting a program, which is calculating avarage grade of class. However you dont know how many student are in class. Or you inserting array which you dont know limits. Then you can use sentinel control for this job.

Lets look this example, 

int grade;
int totalgrade = 0; 
int studentCount = 0;

std::cin >> grade;

while (grade != -1) 
{
totalgrade = totalgrade + grade;
studentCount ++;
std::cin >> grade;
} // loop until user enter -1

So if you dont know how many values will be entered from user, you can use sentinel control for this job. You can also read more about sentinel value.

goGud
  • 4,163
  • 11
  • 39
  • 63
0

These are usually referred to as "ghost cells", and are often used in numerical simulations or image processing where you are applying a kernel (such as a smoothing or difference operator) to an array. They allow you apply the kernel without special casing the edges.

For example; suppose you want to smooth out an image - you could use a kernel like:

0.0   0.1   0.0
0.1   0.6   0.1
0.0   0.1   0.0

You apply this by taking the source image, and for every pixel, you compute the value of the destination pixel by centering the kernel on the source pixel and adding up the weighted contributions of the 9 covered pixel (0.6 * the value of the source pixel, plus 0.1 times the value of each of the pixels above, below, and to the sides). Do this for every pixel and you'll end up with a smoothed version of your original image.

This works well, but the question is "what do you do at the border cells?" Rather than having complicated if/then logic for the border cases (which can be tricky and can degrade performance), you can just add 1 layer of ghost cells to each side.

Of course, you have to pick values for the cells before you run your algorithm. How you pick their value depends on your algorithm. You might choose to set them all to zero, but in the case of the smoothing kernel, this will darken your image at it's borders, so that's probably not what you want. A better plan would be to fill the ghost cells with the value of the nearest non-ghost cell.

You also need to figure out how many ghost cells you need, which depends on the size of your kernel. For a 3x3 kernel like above, you need 1 layer of ghost cells (to take care of the part of the kernel that might "hang off" the edge). More complicated kernels might require more (a 5x5 kernel would require 2 layers, etc).

You can google "ghost cell computation" to find out more (add 'computation' or you'll get a lot of biology results!)

Gretchen
  • 2,274
  • 17
  • 16