Open akasom89 opened 6 months ago
It should not be as discontinuous as that. Are you perhaps combining timesteps that are too far apart?
This is what our pytroll-produced world composite image looks like from a couple of days ago (IR window channels). We can see some discontinuities, but they are much less severe than in your example.
Note that we did not use MultiScene, but a multi-step procedure in which we first resample individual images onto the same global grid, write those individual images to NetCDF, then read those with a different reader, combine them with a composite, enhance, and ready.
Thanks @gerritholl for your detailed answer. Your output is truly much better than mine. Initially, I guessed the issue might be due to the way the MultiScene.blend stack function treats the process. However, some questions have arisen in my mind:
-Which compositor was used for this purpose? -Why write and read again? Isn't it possible to pipe the Scene/XArray directly to the compositor? (Because based on my experience, it may take minutes to be done.)
Thanks in advance! I would also appreciate it if you could share the code if possible.
In code, it would be possible to pipe it directly, but in production we do this entirely with configuration files using pytroll-collectors and trollflow2. Our configuration is a bit too complex to post here in detail, but the approach:
wcm
, store it to NetCDF using the Satpy CF writer (without enhancements), then send a posttroll message;SatpyNCFileHandler
, and loads a custom composite that is based on LongitudeMaskingCompositor
and MultiFiller
(where we define the longitude cutoffs between the different satellites);There are various subtleties, such as dealing with the different repeat cycles (currently 2 × 15 minutes; 3 × 10 minutes; with MTG-I1 FCI it will become 1 × 15 minutes, 4 × 10 minutes), and dealing with missing or delayed data (with masking and clipping, we in this case avoid the cutoff and use the adjecent image up to the edge).
It could be done in Satpy as well, without pytroll-collectors or trollflow2. The advantage of the intermediate files is that you can then use a dedicated reader and corresponding composite to put it all together using LongitudeMaskingCompositor and MultiFiller. You could probably get satpy to recognise those configurations even without storing intermediate files, but good luck with that (we use ramfs for our intermediate files, so it doesn't hurt performance much). You would still need to define a custom reader providing a dataset for each component satellite, and a composite putting them together:
reader:
name: world-nc-image
description: reads intermediate NetCDF files for world composite
reader: !!python/name:satpy.readers.yaml_reader.FileYAMLReader
sensors: [world-images]
file_types:
graphic_goes_east:
file_reader: !!python/name:satpy.readers.satpy_cf_nc.SatpyCFFileHandler
file_patterns:
- 'goes-east-{start_time:%Y%m%d%H%M%S}-{end_time:%Y%m%d%H%M%S}.nc'
graphic_zds:
file_reader: !!python/name:satpy.readers.satpy_cf_nc.SatpyCFFileHandler
file_patterns:
- 'zds-{start_time:%Y%m%d%H%M%S}-{end_time:%Y%m%d%H%M%S}.nc'
# similar for the others
datasets:
image_goes_east:
nc_store_name: C13
name: image_goes_east
file_type: graphic_goes_east
image_zds:
nc_store_name: IR_108
name: image_zds
file_type: graphic_zds
# similar for the others
the composite would be approximately:
world_comp_zds_masked:
compositor: !!python/name:satpy.composites.LongitudeMaskingCompositor
prerequisites:
- image_zds
standard_name: world_comp_zds_masked
lon_min: -37.5
lon_max: 22.75
world_comp_goes_east_masked:
compositor: !!python/name:satpy.composites.LongitudeMaskingCompositor
prerequisites:
- image_goes_east
standard_name: world_comp_goes_east_masked
lon_min: -105.
lon_max: -37.5
# similar for the others
world_comp:
compositor: !!python/name:satpy.composites.MultiFiller
prerequisites:
- name: world_comp_zds_masked
- name: world_comp_goes_masked
- # similar for the others
standard_name: world_comp
Then you just need to load each component satellite, resample to a common world grid, write to NetCDF (no enhancing, and make sure the filenames match the pattern), then load world_comp
from the resulting NetCDF.
Thanks @gerritholl for providing such a detailed and informative answer.
@akasom89 I agree with @gerritholl that your transitions between satellites seems extreme. You could use the MultiScene and stack them. You could go further than a basic stack and define some weights:
https://satpy.readthedocs.io/en/stable/multiscene.html#stacking-scenes-using-weights
But you're still going to have difficulties as the position of the sun on each image is going to be very different. I've seen some people (outside the pytroll community) define individual hour-wide portions of the geostationary images at local noon time and then join all of these images together.
I think there are an endless number of methods for joining geostationary satellite images together and which result is "best" will be subjective and may be dependent on the amount of complexity put into the technique.
There is a great feature named "Multiscene" in Satpy right now, which allows for creating global coverage of different geostationary satellite images. However, the transitions between scenes are currently not smooth, and the steps from one scene to another are easily observable.
I am suggesting an enhancement to improve the visual appeal of the Multiscene feature by making the transitions between satellite images smoother. This could involve applying functions or algorithms that smooth out the transition between scenes, resulting in a more visually pleasing presentation of the data.
I also would like to know if it is currently possible at all to achieve smoother transitions between geostationary satellite images using the Multiscene feature (or combination of different features) in Satpy.