2

I need to "fit" an arbitrarily shaped GraphicsPath into a defined space (almost always a Rectangle or Circle).

I currently scale the GraphicsPath using the Matrix object and the scaling works fine, but the problem is getting the scale factors.

The best technique I can come up with is converting the GraphicsPath to a Region, converting the Rectangle or Circle to a Region, and performing a:

rgnShape.Intersect(rgnCircle);

and then checking if:

rgnShape.IsEmpty()

However, this just tells me if the shape is too large to fit, and it becomes necessary to scale the shape smaller, and try again (possibly many, many times).

Is there an easy way to instantly calculate the scaling factors to fit a polygon GraphicsPath so that it fits entirely into a circle. The result should be the largest polygon that still fits completely within the circle.

Tetsujin no Oni
  • 7,300
  • 2
  • 29
  • 46
Flipster
  • 4,373
  • 4
  • 28
  • 36
  • 2
    Is this is roughly what you're searching for: http://en.wikipedia.org/wiki/Smallest_circle_problem ? – Simon Mourier Jan 01 '11 at 07:56
  • You say 'scaling factor**s**'. Does that mean that X and Y scaling can be different? If not, the caret example isn't clear: If you enlarge the caret (without altering its proportions) until its left and right point touch the left and right edge of the circle on its diameter, the "top point" position is inside, on the edge or outside, as defined by the caret's aspect ratio – smirkingman Jan 03 '11 at 16:27
  • Simon - You know, that's the first really promising lead I've seen. The only problem is that the we have a graphicspath, and not points. So, if we have any large curves where the endpoints would be IN the circle, yet the line would go through it and out. However, it may be possible to do a .Flatten and go through the "smallest circle algorithm" with the flattened points. However, when we start with 1000 points, a .Flatten will give us 10k points... quite a few to put through a complex algorithm. – Flipster Jan 04 '11 at 12:58
  • Simon - write that up into an answer... that's the closest lead yet. – Flipster Jan 04 '11 at 12:58
  • smirkingman - Exactly right. Depending on the angle of the caret, the top point could be inside or touching the circle. It couldn't be outside, though, as that would indicate that the fitting function had failed. There is only 1 scaling factor. – Flipster Jan 04 '11 at 14:52

5 Answers5

2

I don't see why you need the binary search.

Once you get the bounding rectangle for your shape, and you have the target rectangle into which you want to fit the shape, you can compare the two ratios targetHeight / shapeHeight and targetWidth / shapeWidth.

Take the smaller ratio, and use this as the scaling factor to scale your shape.

If the target is a circle and not a rectangle, you can use a similar solution by taking the ratio of targetCircleDiameter / boundingRectangleDiagonal and use this as your scaling factor.

Ran
  • 5,989
  • 1
  • 24
  • 26
  • Thanks for the response, Ran, but that won't cut it either. For a super simple example, picture the lowly caret as our shape ("^"). Fitting that shape properly inside a circle is tricky. Doing a .GetBounds() on that shape would mean that the top "point" of the caret would never actually make it to the edge of the circle at all. Yes, it's easy to fit a rectangle to a circle. But its much harder to fit an arbitrary shape to one...and of course, we are dealing with shapes a lot more complex than "^". – Flipster Dec 30 '10 at 06:54
2

See http://en.wikipedia.org/wiki/Smallest_circle_problem for discussion of this problem in terms of points rather than paths, found by Simon.

  1. So, do that, use rgnShape.Intersect(rgnCircle); to check if it worked. If it failed, take each curve and grab the points farthest from the center of the circle you found (there may be more than one such point for any given region).

  2. Add them to your points list reapply the algorithm. You won't need to start from scratch; you do not need to consider points not on the border (i.e., ignore points not in "Set Q" that was found by the original call to the algorithm).

Note that this is no longer linear, since the probability of generating recursive calls is no longer 1/i for the ith point.

This has one edge condition you must handle explicitly. In the event that one of the curves found found outside the region found during the first iteration of step 1 is perfectly circular and touching the outside circle, there will be infinite points within "Set Q" and this algorithm will fail miserably. So, after applying rgnShape.Intersect(rgnCircle); for the first time, you should check any perfectly round curves explicitely for this case. For example, if your shape is (} you should explicitly check () (for purposes of this discussion, pretend () is a circle) if ( lies outside of the region found during the first iteration.

This is still pretty bad, but it's better than changing every curve into points.

Brian
  • 25,523
  • 18
  • 82
  • 173
  • Hi Brian - Still not ideal, but I think that's about as close as we can get here. I'll start with that, and break some new ground from there. You should give Simon half the points, though... :-) – Flipster Jan 05 '11 at 00:07
0

You could use GetBounds on the GraphicsPath and the Region, then compare the sizes of the rectangles to at least get you close.

If the defined space is a square that should be exact.

If the defined space something else, that would at least get you close. You could then use a binary search to find the actual scaling amount.

mjcopple
  • 1,580
  • 2
  • 13
  • 19
  • That's pretty much exactly what I'm doing now. I am doing a binary search and comparing sizes at each point until I'm "close enough", but this routine gets called hundreds of times a minute. The point of the question is that I am looking for a better solution. – Flipster Dec 30 '10 at 04:34
0

Can't you compute the center of the graphicspath and a radius?

You could either compute center of gravity (average of coordinates) and add 2 times standard deviation - this should get you around 92% of your graph - most of the time it would be good, but will fail if your graph has most 'weight' in one end.

You could also compute the center of the points - run through all points, get max/min points in all directions as when computing boundingbox, take the center of this and measure longest distance to your (max/min) points as radius.

You could probably find a more sophisticated algorithm if you look for a bounding sphere algorithm - but if it is just to display something you could do some trade offs. If you are doing collision detection there exists some quick algorithms for that too :)

Rune Andersen
  • 1,650
  • 12
  • 15
  • All good suggestions, but it needs to be a 'clean fit'. We need to fit an arbitrary shaped graphicspath onto a consumer product (usually a circle or rectangle), and the coordinates for fitting the path are provided to use, and we're expected to "fit" the design into that shape. It seems easy... until you try it. :-) – Flipster Jan 04 '11 at 06:31
  • Ahh - I see :) Fitting in a rectangle should be easy - that is just a boundingbox. Fitting in a circle a bit more tricky - but doable. Fitting in a polygon - probably more tricky. I would switch on rect, circle, triangle and general polygon - the last maybe handfit or biggest internal rect or something. Sounds like a fun problem to solve :) How many point are in your path? – Rune Andersen Jan 04 '11 at 10:33
  • Hi Rune, Good point (no pun intended). I should have stated that there are between 300 and 1200 points on the graphicspath, so its not a trivial number. These are some fairly complex paths. – Flipster Jan 04 '11 at 12:55
0

How about going the opposite way using simple math? Namely, get the bounding box/circle of the path, calculate the predefined rectangular ratio of height/width, compare that to the same value of BB, stretch the BB accordingly (e.g if predefined ration is less than 1, the BB is stretched horizontally and vertically otherwise to match the same ratio), finally scale the whole thing to the predefined rectangular size. The scale factor is now just the minimum between predefined height divided by BB height and predefined width divided by BB width. (For the bounding circle there is no need to adjust its size.)

Schultz9999
  • 8,717
  • 8
  • 48
  • 87
  • You wrote "get the bounding box/circle of the path". Shoot. If I could get the bounding circle of the path, I'd be done! – Flipster Jan 04 '11 at 14:53
  • That's a separate issue from finding a scaling factor. Bounding box is given to you thru GetBounds method. I'll check on circle. – Schultz9999 Jan 04 '11 at 16:57
  • Here a small reading on the bounding circle. It can be done in linear time: http://www.personal.kent.edu/~rmuhamma/Compgeometry/MyCG/CG-Applets/Center/centercli.htm – Schultz9999 Jan 04 '11 at 18:06