docs: def execute(self, eopatch):
          """ Execute method that processes EOPatch and returns EOPatch
          """
          # pylint: disable=too-many-locals
          feature_type, feature_name, new_feature_name = next(self.feature(eopatch))
  
          # Make a copy not to change original numpy array
          feature_data = eopatch[feature_type][feature_name].copy()
          time_num, height, width, band_num = feature_data.shape
          if time_num <= 1:
              raise ValueError('Feature {} has time dimension of size {}, required at least size '
                               '2'.format((feature_type, feature_name), time_num))
  
          # Apply a mask on data
          if self.mask_feature is not None:
              for mask_type, mask_name in self.mask_feature(eopatch):
                  negated_mask = ~eopatch[mask_type][mask_name].astype(np.bool)
                  feature_data = self._mask_feature_data(feature_data, negated_mask, mask_type)
  
          # Flatten array
          feature_data = np.reshape(feature_data, (time_num, height * width * band_num))
  
          # If resampling create new EOPatch
          new_eopatch = EOPatch() if self.resample_range else eopatch
  
          # Resample times
          times = eopatch.time_series(scale_time=self.scale_time)
          new_eopatch.timestamp = self.get_resampled_timestamp(eopatch.timestamp)
          total_diff = int((new_eopatch.timestamp[0].date() - eopatch.timestamp[0].date()).total_seconds())
          resampled_times = new_eopatch.time_series(scale_time=self.scale_time) + total_diff // self.scale_time
  
          # Add BBox to eopatch if it was created anew
          if new_eopatch.bbox is None:
              new_eopatch.bbox = eopatch.bbox
  
          # Replace duplicate acquisitions which have same values on the chosen time scale with their average
          feature_data, times = self._get_unique_times(feature_data, times)
  
          # Interpolate
          feature_data = self.interpolate_data(feature_data, times, resampled_times)
  
          # Normalize
          if self.result_interval:
              min_val, max_val = self.result_interval
              valid_mask = ~np.isnan(feature_data)
              feature_data[valid_mask] = np.maximum(np.minimum(feature_data[valid_mask], max_val), min_val)
  
          # Replace unknown value
          if not np.isnan(self.unknown_value):
              feature_data[np.isnan(feature_data)] = self.unknown_value
  
          # Reshape back
          new_eopatch[feature_type][new_feature_name] = np.reshape(feature_data,
                                                                   (feature_data.shape[0], height, width, band_num))
  
          # append features from old patch
          new_eopatch = self._copy_old_features(new_eopatch, eopatch, self.copy_features)
  
          return new_eopatch