docs: def rio_save(self, filename, fformat=None, fill_value=None,
                   dtype=np.uint8, compute=True, tags=None,
                   keep_palette=False, cmap=None,
                   **format_kwargs):
          """Save the image using rasterio.
  
          Overviews can be added to the file using the `overviews` kwarg, eg::
  
            img.rio_save('myfile.tif', overviews=[2, 4, 8, 16])
  
          """
          fformat = fformat or os.path.splitext(filename)[1][1:4]
          drivers = {'jpg': 'JPEG',
                     'png': 'PNG',
                     'tif': 'GTiff',
                     'jp2': 'JP2OpenJPEG'}
          driver = drivers.get(fformat, fformat)
  
          if tags is None:
              tags = {}
  
          data, mode = self.finalize(fill_value, dtype=dtype,
                                     keep_palette=keep_palette, cmap=cmap)
          data = data.transpose('bands', 'y', 'x')
          data.attrs = self.data.attrs
  
          crs = None
          gcps = None
          transform = None
          if driver in ['GTiff', 'JP2OpenJPEG']:
              if not np.issubdtype(data.dtype, np.floating):
                  format_kwargs.setdefault('compress', 'DEFLATE')
              photometric_map = {
                  'RGB': 'RGB',
                  'RGBA': 'RGB',
                  'CMYK': 'CMYK',
                  'CMYKA': 'CMYK',
                  'YCBCR': 'YCBCR',
                  'YCBCRA': 'YCBCR',
              }
              if mode.upper() in photometric_map:
                  format_kwargs.setdefault('photometric',
                                           photometric_map[mode.upper()])
  
              try:
                  crs = rasterio.crs.CRS(data.attrs['area'].proj_dict)
                  west, south, east, north = data.attrs['area'].area_extent
                  height, width = data.sizes['y'], data.sizes['x']
                  transform = rasterio.transform.from_bounds(west, south,
                                                             east, north,
                                                             width, height)
  
              except KeyError:  # No area
                  logger.info("Couldn't create geotransform")
              except AttributeError:
                  try:
                      gcps = data.attrs['area'].lons.attrs['gcps']
                      crs = data.attrs['area'].lons.attrs['crs']
                  except KeyError:
                      logger.info("Couldn't create geotransform")
  
              if "start_time" in data.attrs:
                  stime = data.attrs['start_time']
                  stime_str = stime.strftime("%Y:%m:%d %H:%M:%S")
                  tags.setdefault('TIFFTAG_DATETIME', stime_str)
          elif driver == 'JPEG' and 'A' in mode:
              raise ValueError('JPEG does not support alpha')
  
          # FIXME add metadata
          r_file = RIOFile(filename, 'w', driver=driver,
                           width=data.sizes['x'], height=data.sizes['y'],
                           count=data.sizes['bands'],
                           dtype=dtype,
                           nodata=fill_value,
                           crs=crs,
                           transform=transform,
                           gcps=gcps,
                           **format_kwargs)
          r_file.open()
          if not keep_palette:
              r_file.colorinterp = color_interp(data)
          r_file.rfile.update_tags(**tags)
  
          if keep_palette and cmap is not None:
              if data.dtype != 'uint8':
                  raise ValueError('Rasterio only supports 8-bit colormaps')
              try:
                  from trollimage.colormap import Colormap
                  cmap = cmap.to_rio() if isinstance(cmap, Colormap) else cmap
                  r_file.rfile.write_colormap(1, cmap)
              except AttributeError:
                  raise ValueError("Colormap is not formatted correctly")
  
          if compute:
              # write data to the file now
              res = da.store(data.data, r_file)
              r_file.close()
              return res
          # provide the data object and the opened file so the caller can
          # store them when they would like. Caller is responsible for
          # closing the file
          return data.data, r_file