Question

I’m having difficulty formulating this elegantly into an algorithm.

So I have a given a straight-edged shape (ie. square, though in the end shape doesn’t matter only endpoints). I get the bounding endpoints on a Cartesian coordinate system : (2,-2) (2,2) (-2,2) (-2,-2)

I’m given an arbitrary number of points (ie. 7) and I want to spread these points (x,y) uniformly along the edges of the shape (in this case a square).

My current idea is to get the total length of all endpoints, divide this by the number of points to get a segment length (which I then normalize against an edge). Then I go from endpoint to endpoint finding the point between by this amount and accrue the normalized slice, when this total exceeds 1.0 I iterate the endpoint and take the remainder and start from there…or something like that.

Could someone help me put this into an algorithm (C# preferably) or if you have a better solution please do tell. I’d imagine there is a sorting or distribution/division algorithm that could have the same affect, but I couldn’t find any. I hope this isn’t blatantly obvious.

Answer 1

How general does this need to be? Also, how are representing your shape, and the points? Your algorithm seems to be ok; do you need help turning it into code?

---

Alrighty, here’s something i came up with.
Notes on the code:

• The distance method takes two Points and returns the distance between them.
• The normalize method takes two points and returns the normal vector pointing from the first point to the second point.
• The Point class has the multiply method which multiplies the point by a scalar
• The Point class has float (or double) precision

I’m using the Point class to represent vectors by the way.

I haven’t tested this, so there might be bugs. There might be issues with how this algorithm handles exact regions (e.g. your square with exactly 4 points on it). Let me know if there are issues or if you have any questions! 🙂

Point[] shapePoints; //already initialized
int numPoints; //already initialized
Point[] retPoints = new Point[numPoints];
int totalLength;
for(int i = 1; i < shapePoints.length; i++){
    totalLength += distance(shapePoints[i], (shapePoints[i-1]));
}
float segLength = ((float) totalLength) / numPoints);
Point currShape = shapePoints[0];
Point nextShape = shapePoints[1];
Point prev = currShape;
int counter = 2;
while(numPoints > 0){
    Point norm = normalize(new Point(nextShape.x - currShape.x, nextShape.y - currShape.y));
    if(distance(nextShape, prev) < segLength){
        int tempLength = segLength;
        tempLength -= distance(nextShape, prev);
        currShape = nextShape;
        nextShape = shapePoints[counter];
        counter ++;
        norm = normalize(new Point(nextShape.x - currShape.x, nextShape.y - currShape.y));
        norm.multiply(tempLength);
    }
    else{
        norm.multiply(segLength);
    }       
    retPoints[numPoints - 1] = norm;
    prev = retPoints[numPoints - 1];
    numPoints --;
}

---

Point normalize(Point p){
    int scale = Math.sqrt(p.x * p.x + p.y * p.y);
    p.x = p.x / scale;
    p.y = p.y / scale;
    return p;
}