Fixed coverage map output

Author: GermanHydrogen

.gitignore

@@ -71,4 +71,7 @@ docs/_build/
 # Pyenv
 .python-version
 
-*.sh
+*.sh
+
+**/ipynb_checkpoints
+*.ipynb

Cargo.lock

@@ -62,7 +62,7 @@ modules:
           mask_filepath: "data/mask.npy"
           sun_apparent_size: 0.54
           cloud_map:
-            threshold: 3.5
+            threshold: 3.0
 
     comm:
       class: pyobs.comm.local.LocalComm
@@ -71,10 +71,10 @@ modules:
   tester:
     class: pyobs_cloudcover.testing.TestModule
     image_path: "data/test_day_image.fits"
-    total_fraction: 0.7
+    total_fraction: 0.3
     zenith_fraction: 0.02
-    zenith_value: False
-    zenith_average: 2.3
+    zenith_value: True
+    zenith_average: 5.8
 
     comm:
       class: pyobs.comm.local.LocalComm

data/mask.npy

@@ -5,7 +5,8 @@
 
 
 class CloudCoverageInfo(object):
-    def __init__(self, cloud_cover_query: SkyPixelQuery, change: Optional[float], obs_time: datetime.datetime) -> None:
+    def __init__(self, cloud_cover_query: SkyPixelQuery, change: Optional[float], cloud_plot: bytes, obs_time: datetime.datetime) -> None:
         self.cloud_cover_query = cloud_cover_query
         self.change = change
+        self.cloud_plot = cloud_plot
         self.obs_time = obs_time

day_integration_test.yaml

@@ -1,20 +1,19 @@
 import datetime
 
 import numpy as np
-from cloudmap_rs import AltAzCoord, SkyPixelQuery
+import numpy.typing as npt
+from cloudmap_rs import SkyPixelQuery
 
 from pyobs_cloudcover.cloud_coverage_info import CloudCoverageInfo
 from pyobs_cloudcover.cloud_info_calculator.coverage_change_calculator import \
     CoverageChangeCalculator
-from pyobs_cloudcover.measurement_log.field_evaluators.zenith_cloud_coverage_calculator import \
-    ZenithCloudCoverageCalculator
 
 
 class CoverageInfoCalculator:
     def __init__(self, coverage_change_calculator: CoverageChangeCalculator) -> None:
         self._coverage_change_calculator = coverage_change_calculator
 
-    def __call__(self, sky_query: SkyPixelQuery, obs_time: datetime.datetime) -> CloudCoverageInfo:
+    def __call__(self, sky_query: SkyPixelQuery, cloud_plot: bytes, obs_time: datetime.datetime) -> CloudCoverageInfo:
         change = self._coverage_change_calculator(sky_query.get_pixels())
 
-        return CloudCoverageInfo(sky_query, change, obs_time)
+        return CloudCoverageInfo(sky_query, change, cloud_plot, obs_time)

poetry.lock

@@ -0,0 +1,32 @@
+import io
+from typing import List
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from cloudmap_rs import AltAzCoord
+
+
+def plot_clouds(coordinates: List[AltAzCoord], clouds: List[bool]) -> bytes:
+    '''
+    z = 90 - np.rad2deg([coord.alt for coord in coordinates])
+    az = np.rad2deg([coord.az for coord in coordinates])
+    plt.polar()
+    plt.scatter(az, z, c=clouds, s=1)
+    plt.colorbar()
+    '''
+
+    lon, lat = [coord.az for coord in coordinates], [coord.alt for coord in coordinates]
+    plt.polar()
+    plt.scatter(lon, 90 - np.rad2deg(lat), c=clouds, s=1)
+    plt.colorbar()
+
+    return render_plot()
+
+def render_plot() -> bytes:
+    buffer = io.BytesIO()
+    plt.savefig(buffer, format='png')
+    buffer.seek(0)
+    plt.close()
+
+    return buffer.read()

pyobs_cloudcover/cloud_coverage_info.py

@@ -1,19 +1,23 @@
 import datetime
+from copy import copy
 from itertools import compress
 from typing import List, Any, Optional
 
+import matplotlib.pyplot as plt
 import numpy as np
 from numpy import typing as npt
 
 from cloudmap_rs import SkyPixelQuery
 
 from pyobs_cloudcover.cloud_coverage_info import CloudCoverageInfo
 from pyobs_cloudcover.cloud_info_calculator import CoverageInfoCalculator
+from pyobs_cloudcover.cloud_plot.cloud_plotter import plot_clouds, render_plot
 from pyobs_cloudcover.pipeline.day.color_ratio_calculation import calc_color_ratio
 from pyobs_cloudcover.pipeline.day.debayer_image import debayer_image
 from pyobs_cloudcover.pipeline.day.sun_masker import SunMasker
 from pyobs_cloudcover.pipeline.day.altaz_map_generator import AltAzMapGenerator
 from pyobs_cloudcover.pipeline.night.cloud_map_generator.cloud_map_generator import CloudMapGenerator
+from pyobs_cloudcover.pipeline.night.preprocessor.image_binner import ImageBinner
 from pyobs_cloudcover.pipeline.pipeline import Pipeline
 
 
@@ -28,22 +32,34 @@ def __init__(self, mask: npt.NDArray[np.bool_], alt_az_generator: AltAzMapGenera
         self._sky_query: Optional[SkyPixelQuery] = None
         self._alt_az_mask: Optional[npt.NDArray[np.bool_]] = None
 
+        self._image_binner = ImageBinner(2)
+
     def __call__(self, image: npt.NDArray[np.float_], obs_time: datetime.datetime) -> CloudCoverageInfo:
         debayered_image = debayer_image(image)
-        color_ratio_image = calc_color_ratio(debayered_image).flatten()
-        cloud_map = self._cloud_map_generator(color_ratio_image)
+        color_ratio_image = calc_color_ratio(debayered_image)#.flatten()
+        cloud_map = self._image_binner(self._cloud_map_generator(color_ratio_image))
 
-        if self._sky_query is None or self._alt_az_mask is None:
-            alt_az_points = self.flatten(self._alt_az_generator(*image.shape))
-            self._alt_az_mask = self._mask.flatten() & np.array([x is not None for x in alt_az_points])
 
-            self._sky_query = SkyPixelQuery(self.filter(alt_az_points, self._alt_az_mask), cloud_map[self._alt_az_mask]) # type: ignore
+        if self._sky_query is None or self._alt_az_mask is None:
+            alt_az_points = self.flatten(self._alt_az_generator(*cloud_map.shape))
+            self._alt_az_mask = self._mask.flatten().astype(np.bool_) & np.array([x is not None for x in alt_az_points]).astype(np.bool_)
+            flat_cloud_map =  self._to_python_type(cloud_map)
+            self._sky_query = SkyPixelQuery(self.filter(alt_az_points, self._alt_az_mask), self.filter(flat_cloud_map, self._alt_az_mask)) # type: ignore
         else:
             self._sky_query.set_pixels(cloud_map[self._alt_az_mask])
 
         sky_query = self._sun_masker(self._sky_query, obs_time)
 
-        return self._coverage_info_calculator(sky_query, obs_time)
+        cloud_plot = cloud_map.astype(np.float_).flatten()
+        cloud_plot[~self._alt_az_mask] = np.nan
+        plt.imshow(cloud_plot.reshape(cloud_map.shape))
+
+        return self._coverage_info_calculator(sky_query, render_plot(),obs_time)
+
+
+    def _to_python_type(self, cloud_map: npt.NDArray[np.float_]) -> List[bool]:
+        flat_map = self.flatten(list(cloud_map > 0.5))
+        return list(map(bool, flat_map))
 
     @staticmethod
     def flatten(map_2d: List[List[Any]]) -> List[Any]: