How can you stitch multiple heightmaps together to remove seams?

僤鯓⒐⒋嵵緔 提交于 2020-02-06 00:49:20

问题


I am trying to write an algorithm (in c#) that will stitch two or more unrelated heightmaps together so there is no visible seam between the maps. Basically I want to mimic the functionality found on this page : http://www.bundysoft.com/wiki/doku.php?id=tutorials:l3dt:stitching_heightmaps

(You can just look at the pictures to get the gist of what I'm talking about)

I also want to be able to take a single heightmap and alter it so it can be tiled, in order to create an endless world (All of this is for use in Unity3d). However, if I can stitch multiple heightmaps together, I should be able to easily modify the algorithm to act on a single heightmap, so I am not worried about this part.

Any kind of guidance would be appreciated, as I have searched and searched for a solution without success. Just a simple nudge in the right direction would be greatly appreciated! I understand that many image manipulation techniques can be applied to heightmaps, but have been unable to find a image processing algorithm that produces the results I'm looking for. For instance, image stitching appears to only work for images that have overlapping fields of view, which is not the case with unrelated heightmaps.

Would utilizing a FFT low pass filter in some way work, or would that only be useful in generating a single tileable heightmap?

Because the algorithm is to be used in Unit3d, any c# code will have to be confined to .Net 3.5, as I believe that's the latest version Unity uses. Thanks for any help!


回答1:


Okay, seems I was on the right track with my previous attempts at solving this problem. My initial attemp at stitching the heightmaps together involved the following steps for each point on the heightmap:

1) Find the average between a point on the heightmap and its opposite point. The opposite point is simply the first point reflected across either the x axis (if stitching horizontal edges) or the z axis (for the vertical edges).

2) Find the new height for the point using the following formula:

newHeight = oldHeight + (average - oldHeight)*((maxDistance-distance)/maxDistance);

Where distance is the distance from the point on the heightmap to the nearest horizontal or vertical edge (depending on which edge you want to stitch). Any point with a distance less than maxDistance (which is an adjustable value that effects how much of the terrain is altered) is adjusted based on this formula.

That was the old formula, and while it produced really nice results for most of the terrain, it was creating noticeable lines in the areas between the region of altered heightmap points and the region of unaltered heightmap points. I realized almost immediately that this was occurring because the slope of the altered regions was too steep in comparison to the unaltered regions, thus creating a noticeable contrast between the two. Unfortunately, I went about solving this issue the wrong way, looking for solutions on how to blur or smooth the contrasting regions together to remove the line.

After very little success with smoothing techniques, I decided to try and reduce the slope of the altered region, in the hope that it would better blend with the slope of the unaltered region. I am happy to report that this has improved my stitching algorithm greatly, removing 99% of the lines reported above.

The main culprit from the old formula was this part:

(maxDistance-distance)/maxDistance

which was producing a value between 0 and 1 linearly based on the distance of the point to the nearest edge. As the distance between the heightmap points and the edge increased, the heightmap points would utilize less and less of the average (as defined above), and shift more and more towards their original values. This linear interpolation was the cause of the too step slope, but luckily I found a built in method in the Mathf class of Unity's API that allows for quadratic (I believe cubic) interpolation. This is the SmoothStep Method.

Using this method (I believe a similar method can be found in the Xna framework found here), the change in how much of the average is used in determining a heightmap value becomes very severe in middle distances, but that severity lessens exponentially the closer the distance gets to maxDistance, creating a less severe slope that better blends with the slope of the unaltered region. The new forumla looks something like this:

//Using Mathf - Unity only?
float weight = Mathf.SmoothStep(1f, 0f, distance/maxDistance);

//Using XNA
float weight = MathHelper.SmoothStep(1f, 0f, distance/maxDistance);

//If you can't use either of the two methods above
float input = distance/maxDistance;
float weight = 1f + (-1f)*(3f*(float)Math.Pow(input, 2f) - 2f*(float)Math.Pow(input, 3f));

//Then calculate the new height using this weight
newHeight = oldHeight + (average - oldHeight)*weight;

There may be even better interpolation methods that produce better stitching. I will certainly update this question if I find such a method, so anyone else looking to do heightmap stitching can find the information they need. Kudos to rincewound for being on the right track with linear interpolation!




回答2:


What is done in the images you posted looks a lot like simple linear interpolation to me. So basically: You take two images (Left, Right) and define a stitching region. For linear interpolation you could take the leftmost pixel of the left image (in the stitching region) and the rightmost pixel of the right image (also in the stitching region). Then you fill the space in between with interpolated values.

Take this example - I'm using a single line here to show the idea:

Left = [11,11,11,10,10,10,10]
Right= [01,01,01,01,02,02,02]

Lets say our overlap is 4 pixels wide:

 Left = [11,11,11,10,10,10,10]
 Right=          [01,01,01,01,02,02,02]
                   ^  ^  ^  ^ overlap/stitiching region.

The leftmost value of the left image would be 10 The rightmost value of the right image would be 1. Now we interpolate linearly between 10 and 1 in 2 steps, our new stitching region looks as follows

stitch = [10, 07, 04, 01]

We end up with the following stitched line:

line = [11,11,11,10,07,04,01,02,02,02]

If you apply this to two complete images you should get a result similar to what you posted before.



来源:https://stackoverflow.com/questions/16433122/how-can-you-stitch-multiple-heightmaps-together-to-remove-seams

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!