vkit.mechanism.distortion_policy.photometric.blur

  1# Copyright 2022 vkit-x Administrator. All Rights Reserved.
  2#
  3# This project (vkit-x/vkit) is dual-licensed under commercial and SSPL licenses.
  4#
  5# The commercial license gives you the full rights to create and distribute software
  6# on your own terms without any SSPL license obligations. For more information,
  7# please see the "LICENSE_COMMERCIAL.txt" file.
  8#
  9# This project is also available under Server Side Public License (SSPL).
 10# The SSPL licensing is ideal for use cases such as open source projects with
 11# SSPL distribution, student/academic purposes, hobby projects, internal research
 12# projects without external distribution, or other projects where all SSPL
 13# obligations can be met. For more information, please see the "LICENSE_SSPL.txt" file.
 14from typing import Tuple
 15
 16import attrs
 17from numpy.random import Generator as RandomGenerator
 18
 19from vkit.mechanism import distortion
 20from ..type import DistortionConfigGenerator, DistortionPolicyFactory
 21from ..opt import sample_int, sample_float
 22
 23
 24@attrs.define
 25class GaussianBlurConfigGeneratorConfig:
 26    sigma_min: float = 0.5
 27    sigma_max: float = 1.0
 28
 29
 30class GaussianBlurConfigGenerator(
 31    DistortionConfigGenerator[
 32        GaussianBlurConfigGeneratorConfig,
 33        distortion.GaussianBlurConfig,
 34    ]
 35):  # yapf: disable
 36
 37    def __call__(self, shape: Tuple[int, int], rng: RandomGenerator):
 38        sigma = sample_float(
 39            level=self.level,
 40            value_min=self.config.sigma_min,
 41            value_max=self.config.sigma_max,
 42            prob_reciprocal=None,
 43            rng=rng,
 44        )
 45
 46        return distortion.GaussianBlurConfig(sigma=sigma)
 47
 48
 49gaussian_blur_policy_factory = DistortionPolicyFactory(
 50    distortion.gaussian_blur,
 51    GaussianBlurConfigGenerator,
 52)
 53
 54
 55@attrs.define
 56class DefocusBlurConfigGeneratorConfig:
 57    radius_min: int = 1
 58    radius_max: int = 2
 59
 60
 61class DefocusBlurConfigGenerator(
 62    DistortionConfigGenerator[
 63        DefocusBlurConfigGeneratorConfig,
 64        distortion.DefocusBlurConfig,
 65    ]
 66):  # yapf: disable
 67
 68    def __call__(self, shape: Tuple[int, int], rng: RandomGenerator):
 69        radius = sample_int(
 70            level=self.level,
 71            value_min=self.config.radius_min,
 72            value_max=self.config.radius_max,
 73            prob_negative=None,
 74            rng=rng,
 75        )
 76
 77        return distortion.DefocusBlurConfig(radius=radius)
 78
 79
 80defocus_blur_policy_factory = DistortionPolicyFactory(
 81    distortion.defocus_blur,
 82    DefocusBlurConfigGenerator,
 83)
 84
 85
 86@attrs.define
 87class MotionBlurConfigGeneratorConfig:
 88    radius_min: int = 1
 89    radius_max: int = 2
 90
 91
 92class MotionBlurConfigGenerator(
 93    DistortionConfigGenerator[
 94        MotionBlurConfigGeneratorConfig,
 95        distortion.MotionBlurConfig,
 96    ]
 97):  # yapf: disable
 98
 99    def __call__(self, shape: Tuple[int, int], rng: RandomGenerator):
100        radius = sample_int(
101            level=self.level,
102            value_min=self.config.radius_min,
103            value_max=self.config.radius_max,
104            prob_negative=None,
105            rng=rng,
106        )
107        angle = rng.integers(0, 360)
108
109        return distortion.MotionBlurConfig(
110            radius=radius,
111            angle=angle,
112        )
113
114
115motion_blur_policy_factory = DistortionPolicyFactory(
116    distortion.motion_blur,
117    MotionBlurConfigGenerator,
118)
119
120
121@attrs.define
122class GlassBlurConfigGeneratorConfig:
123    sigma_min: float = 0.5
124    sigma_max: float = 1.0
125    delta_min: int = 1
126    delta_max: int = 1
127    loop_min: int = 1
128    loop_max: int = 4
129
130
131class GlassBlurConfigGenerator(
132    DistortionConfigGenerator[
133        GlassBlurConfigGeneratorConfig,
134        distortion.GlassBlurConfig,
135    ]
136):  # yapf: disable
137
138    def __call__(self, shape: Tuple[int, int], rng: RandomGenerator):
139        sigma = sample_float(
140            level=self.level,
141            value_min=self.config.sigma_min,
142            value_max=self.config.sigma_max,
143            prob_reciprocal=None,
144            rng=rng,
145        )
146        delta = sample_int(
147            level=self.level,
148            value_min=self.config.delta_min,
149            value_max=self.config.delta_max,
150            prob_negative=None,
151            rng=rng,
152        )
153        loop = sample_int(
154            level=self.level,
155            value_min=self.config.loop_min,
156            value_max=self.config.loop_max,
157            prob_negative=None,
158            rng=rng,
159        )
160
161        return distortion.GlassBlurConfig(
162            sigma=sigma,
163            delta=delta,
164            loop=loop,
165        )
166
167
168glass_blur_policy_factory = DistortionPolicyFactory(
169    distortion.glass_blur,
170    GlassBlurConfigGenerator,
171)
172
173
174@attrs.define
175class ZoomInBlurConfigGeneratorConfig:
176    ratio_min: float = 0.01
177    ratio_max: float = 0.1
178    step_min: float = 0.002
179    step_max: float = 0.02
180    alpha_min: float = 0.5
181    alpha_max: float = 0.7
182
183
184class ZoomInBlurConfigGenerator(
185    DistortionConfigGenerator[
186        ZoomInBlurConfigGeneratorConfig,
187        distortion.ZoomInBlurConfig,
188    ]
189):  # yapf: disable
190
191    def __call__(self, shape: Tuple[int, int], rng: RandomGenerator):
192        ratio = sample_float(
193            level=self.level,
194            value_min=self.config.ratio_min,
195            value_max=self.config.ratio_max,
196            prob_reciprocal=None,
197            rng=rng,
198        )
199        step = sample_float(
200            level=self.level,
201            value_min=self.config.step_min,
202            value_max=self.config.step_max,
203            prob_reciprocal=None,
204            rng=rng,
205        )
206        alpha = rng.uniform(self.config.alpha_min, self.config.alpha_max)
207
208        return distortion.ZoomInBlurConfig(
209            ratio=ratio,
210            step=step,
211            alpha=alpha,
212        )
213
214
215zoom_in_blur_policy_factory = DistortionPolicyFactory(
216    distortion.zoom_in_blur,
217    ZoomInBlurConfigGenerator,
218)