Originally posted by Anubis3.14
if you could show me some examples to prove your theory , that would be great. Im sure with all this logic, there has to be examples other then moon
shots right?
Some of the
Viking shots exhibited vertical banding, but that was caused by
vibrations in the spacecraft while the camera image was being copied to the tape recorder.
The type of vertical banding that I'm describing (based on programmatic interpolation, not a problem with the images themselves) is only going to
happen with a mosaic. Panoramic shots occasionally
exhibit vertical
banding, but usually it's
due to variation in exposures or
misalignment. These moon smudges are different, because not only are there slight variations in exposure
there's also
missing data.
Mosaics of a planet or a satellite (like the moon) are "uglier" than panoramic shots because of lighting changes, the distance from the surface
varies, atmospheric distortions warp ground geography (assuming an atmosphere), and weather systems occult ground data. For example lets take this
mosaic of Hurricane Norbert and Tropical Storm Odile.
Notice that there are overlapping segments especially at the poles. Also notice that the program generating the mosaic (MOSRI) doesn't blend the
longitudinal strips together. It creates a hard distinctive edge. This image is a particularly good example because there's also a whole strip
missing. If you look at the 5th vertical band from the left-edge you'll see MOSRI shaded it an empty blue rather than trying to "patch in" or
interpolate the missing data.
Now I want you to think about how you would blend these strips together to make them look like they're part of the same contiguous picture. Okay, now
that you've thought about that think about how you would go about filling in the missing data.
In the naïve case you would smudge one pixel from the left hand-side strip to the right-hand side of the next strip. Like so:
to
A more common technique is to use non-parametric sampling, reconstructing the empty area by comparing the window around one pixel with other non-empty
areas, trying to locate a good fit for the edge pixels and then tiling.
IE/
(using a 6x6 pixel tile)
There are
better ways to do this, but they're computationally expensive
and requires a certain amount of training to calculate a good estimation mapping filter.
What I described above are ways to patch a hole in an image. The Clementine data-set is somewhat special by comparison. There's more information to
work with because there's LIDAR data (providing height information) as well as UV and infra-red; with many shots taken numerous times using different
wave-lengths. So when there's missing visual data there's still potentially useful information to help reconstruct the visual frame.
Lets look at the section you called out in
your previous post:
Desired Resolution: 1 pixel = 1 kilometer
- Image Size = 768x768
- Latitude = 0
- Longitude = 318
If you click the
identified segment (0º23'N, 32º40'E) you should see the following:
Click the arrow to the right (which will center you on the vertical line in question) and you'll get '
This Image is
Unavailable.'
It should be somewhat obvious now that the program is simply trying to stitch two
non-adjacent segments together (n-1 and n+1), interpolating
the missing segment (n), and in the process creating a somewhat distorted image. Had the program done a better job using say the additional UV data it
could have gray-scaled the image, looked at the luminosity of the neighboring frames, and then normalized the lighting. Then the image could have been
composited and sampled to create the 768x768; 1pixel = 1km mosaic, which likely would have looked much better than what we get with the 1st rev of the
Clementine Lunar Image Browser.
Im mean, how could you come up with sure info if there were no other examples?
Not to toot my own horn, but I'm a game programmer (worked on Age of Empires 3, Rise of Nations: Rise of Legends, Lord of the Rings: Conquest, Xbox
Live Anywhere, etc. ) and I occasionally do graphics programming.
If you ever try to rasterize even a simple BMP you'll see for yourself that alignment issues create very funny image distortions. Once you start
playing with more complicated stream-based formats graphical artifacts arise (a) if you don't process the data correctly or (b) if the data's
damaged. Things get even more hairy when you try to map a 2D texture using UV coordinates to a 3D model (which is somewhat like creating a mosaic,
just in 3D instead of 2D) and you blend two adjacent textures to clean up the seam or to address terrain LOD issues. Blending is expensive so usually
this is done statically either through a preprocessing tool or by hand. It's rarely done at run-time.
So I can say with a certain amount of authority based off my own experiences that this is likely the case. Then to confirm my suspicions I did a
little bit of research to see how NASA dealt with the problems described above. A few Google queries later I discovered NASA has a team, the
Scientific Visual Studio (SVS), at Goddard that investigated
"accurately and efficiently
[mapping] data sets to geometry allowing for animations with few perceptual transitions among data sets".
That's how I know