wsi = OpenSlideWSIReader(
                input_img='/input/path/to/image.tiff')

wsi_info = wsi.info.as_dict()
# Print one item per line
print(*list(wsi_info.items()), sep='\n')

wsi_thumb = wsi.slide_thumbnail()
plt.imshow(wsi_thumb)
plt.axis('off')
plt.show()

openslide_wsi = openslide.OpenSlide(filename='/input/path/to/image.tiff')

openslide_thumb = openslide_wsi.get_thumbnail(size=(256, 256))
plt.imshow(openslide_thumb)
plt.axis('off')
plt.show()

/home/giorgos-tia/.conda/envs/wsic/lib/python3.9/site-packages/wsic/readers.py:265: UserWarning: Failed to get next tile after 100 attempts. Dumping debug information.
  warnings.warn(
Reader Shape (161864, 88832, 3)
Read Tile Size (4096, 4096)
Yield Tile Size (256, 256)
Read Mosaic Shape (40, 22)
Yield Mosaic Shape (633, 347)
Read Index (0, 0)
Yield Index (0, 0)
Remaining Reads (:10) [(0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (0, 11)]
Enqueued {(0, 1), (0, 0)}
Reordering Dict (keys) dict_keys([])
Queue Size 0
Intermediate Read slices (slice(0, 256, None), slice(0, 256, None))
Traceback (most recent call last):
  File "/home/giorgos-tia/.conda/envs/wsic/bin/wsic", line 8, in <module>
    sys.exit(main())
  File "/home/giorgos-tia/.conda/envs/wsic/lib/python3.9/site-packages/click/core.py", line 1130, in __call__
    return self.main(*args, **kwargs)
  File "/home/giorgos-tia/.conda/envs/wsic/lib/python3.9/site-packages/click/core.py", line 1055, in main
    rv = self.invoke(ctx)
  File "/home/giorgos-tia/.conda/envs/wsic/lib/python3.9/site-packages/click/core.py", line 1657, in invoke
    return _process_result(sub_ctx.command.invoke(sub_ctx))
  File "/home/giorgos-tia/.conda/envs/wsic/lib/python3.9/site-packages/click/core.py", line 1404, in invoke
    return ctx.invoke(self.callback, **ctx.params)
  File "/home/giorgos-tia/.conda/envs/wsic/lib/python3.9/site-packages/click/core.py", line 760, in invoke
    return __callback(*args, **kwargs)
  File "/home/giorgos-tia/.conda/envs/wsic/lib/python3.9/site-packages/wsic/cli.py", line 126, in convert
    writer.copy_from_reader(reader, read_tile_size=read_tile_size, num_workers=workers)
  File "/home/giorgos-tia/.conda/envs/wsic/lib/python3.9/site-packages/wsic/writers.py", line 513, in copy_from_reader
    tif.write(
  File "/home/giorgos-tia/.conda/envs/wsic/lib/python3.9/site-packages/tifffile/tifffile.py", line 2660, in write
    for tileindex, chunk in enumerate(
  File "/home/giorgos-tia/.conda/envs/wsic/lib/python3.9/site-packages/tifffile/tifffile.py", line 16817, in encode_tiles
    tile = next(tileiter)
  File "/home/giorgos-tia/.conda/envs/wsic/lib/python3.9/site-packages/wsic/readers.py", line 284, in __next__
    raise Exception(f"Failed to yield tile {self.yield_index}")
Exception: Failed to yield tile (0, 0)

    def qsize(self):
        # Raises NotImplementedError on Mac OSX because of broken sem_getvalue()
        return self._maxsize - self._sem._semlock._get_value()

Traceback (most recent call last):
  File "/opt/miniconda3/envs/wsic/bin/wsic", line 8, in <module>
    sys.exit(main())
  File "/opt/miniconda3/envs/wsic/lib/python3.9/site-packages/click/core.py", line 1130, in __call__
    return self.main(*args, **kwargs)
  File "/opt/miniconda3/envs/wsic/lib/python3.9/site-packages/click/core.py", line 1055, in main
    rv = self.invoke(ctx)
  File "/opt/miniconda3/envs/wsic/lib/python3.9/site-packages/click/core.py", line 1657, in invoke
    return _process_result(sub_ctx.command.invoke(sub_ctx))
  File "/opt/miniconda3/envs/wsic/lib/python3.9/site-packages/click/core.py", line 1404, in invoke
    return ctx.invoke(self.callback, **ctx.params)
  File "/opt/miniconda3/envs/wsic/lib/python3.9/site-packages/click/core.py", line 760, in invoke
    return __callback(*args, **kwargs)
  File "/opt/miniconda3/envs/wsic/lib/python3.9/site-packages/wsic/cli.py", line 139, in convert
    writer.copy_from_reader(
  File "/opt/miniconda3/envs/wsic/lib/python3.9/site-packages/wsic/writers.py", line 527, in copy_from_reader
    tif.write(
  File "/opt/miniconda3/envs/wsic/lib/python3.9/site-packages/tifffile/tifffile.py", line 2660, in write
    for tileindex, chunk in enumerate(
  File "/opt/miniconda3/envs/wsic/lib/python3.9/site-packages/tifffile/tifffile.py", line 16817, in encode_tiles
    tile = next(tileiter)
  File "/opt/miniconda3/envs/wsic/lib/python3.9/site-packages/wsic/readers.py", line 281, in __next__
    print(f"Queue Size {self.queue.qsize()}")
  File "/opt/miniconda3/envs/wsic/lib/python3.9/multiprocessing/queues.py", line 126, in qsize
    return self._maxsize - self._sem._semlock._get_value()
NotImplementedError

Traceback (most recent call last):
  File "/opt/miniconda3/envs/wsic/lib/python3.9/multiprocessing/popen_fork.py", line 27, in poll
Process Process-1:
    pid, sts = os.waitpid(self.pid, flag)
KeyboardInterrupt
Traceback (most recent call last):
  File "/opt/miniconda3/envs/wsic/lib/python3.9/multiprocessing/process.py", line 318, in _bootstrap
    util._exit_function()
  File "/opt/miniconda3/envs/wsic/lib/python3.9/multiprocessing/util.py", line 360, in _exit_function
    _run_finalizers()
  File "/opt/miniconda3/envs/wsic/lib/python3.9/multiprocessing/util.py", line 300, in _run_finalizers
    finalizer()
  File "/opt/miniconda3/envs/wsic/lib/python3.9/multiprocessing/util.py", line 224, in __call__
    res = self._callback(*self._args, **self._kwargs)
  File "/opt/miniconda3/envs/wsic/lib/python3.9/multiprocessing/queues.py", line 201, in _finalize_join
    thread.join()
  File "/opt/miniconda3/envs/wsic/lib/python3.9/threading.py", line 1053, in join
    self._wait_for_tstate_lock()
  File "/opt/miniconda3/envs/wsic/lib/python3.9/threading.py", line 1073, in _wait_for_tstate_lock
    if lock.acquire(block, timeout):
KeyboardInterrupt
(wsic) ghadjigeorgiou@192 jp2tiff % /opt/miniconda3/envs/wsic/lib/python3.9/multiprocessing/resource_tracker.py:216: UserWarning: resource_tracker: There appear to be 1 leaked semaphore objects to clean up at shutdown
  warnings.warn('resource_tracker: There appear to be %d '

from codecs import Codec
from ctypes.wintypes import HCOLORSPACE
from functools import partial
from math import floor
import multiprocessing
from os import PathLike
from pathlib import Path
from typing import Generator, List, Optional, Tuple

import numpy as np
import wsic

from wsic.utils import warn_unused, mosaic_shape
from wsic.readers import Reader
from wsic.writers import ZarrIntermediate, ColorSpace, DICOMWSIWriter, get_level_tile
from wsic.enums import ColorSpace

class DICOMWSIWriterMultiLevel(DICOMWSIWriter):
    """Writer for DICOM WSI images using wsidicom and supports multiple levels.

    Notes:
        - Supports JPEG and JPEG2000 compression.
        - DICOM Whole Slide Imaging:  https://dicom.nema.org/Dicom/DICOMWSI/
    """

    def __init__(
        self,
        path: PathLike,
        shape: Tuple[int, int],
        tile_size: Tuple[int, int] = (256, 256),
        dtype: np.dtype = np.uint8,
        color_space: Optional[HCOLORSPACE] = None,
        codec: Optional[Codec] = None,
        compression_level: int = 0,
        microns_per_pixel: Tuple[float, float] = None,
        pyramid_downsamples: Optional[List[int]] = None,
        overwrite: bool = False,
        verbose: bool = False,
        **kwargs,
    ) -> None:
        if color_space != "rgb":
            warn_unused(color_space)
        warn_unused(codec)
        warn_unused(compression_level, ignore_falsey=True)
        warn_unused(microns_per_pixel)

        for key, value in kwargs.items():
            warn_unused(key, value)
        super().__init__(
            path=path,
            shape=shape,
            tile_size=tile_size,
            dtype=dtype,
            color_space=color_space,
            codec=codec,
            compression_level=compression_level,
            microns_per_pixel=microns_per_pixel,
            pyramid_downsamples=pyramid_downsamples,
            overwrite=overwrite,
            verbose=verbose,
        )


    def copy_from_reader(
        self,
        reader: Reader,
        num_workers: int = 2,
        read_tile_size: Tuple[int, int] = None,
        timeout: float = 10,
        downsample_method: Optional[str] = None,
    ) -> None:
        from pydicom import FileDataset, dcmwrite

        from wsic.dicom import append_frames, create_vl_wsi_dataset

        width = self.shape[1]
        height = self.shape[0]
        photometric_interpretation = (
            ColorSpace.YCBCR.to_dicom_photometric_interpretation((4, 2, 2))
        )
        mpp: Tuple[float, float] = (
            self.microns_per_pixel or reader.microns_per_pixel or (1.0, 1.0)
        )
        self.validate_write_args(microns_per_pixel=mpp)

        meta, dataset = create_vl_wsi_dataset(
            size=(width, height),
            tile_size=self.tile_size,
            microns_per_pixel=mpp,
            photometric_interpretation=photometric_interpretation,
        )

        file_dataset = FileDataset(
            str(self.path),
            dataset=dataset,
            preamble=b"\0" * 128,
            file_meta=meta,
            is_implicit_VR=False,
            is_little_endian=True,
        )

        level_path = str(self.path.parent / f"{self.path.stem}_{0}.dcm")
        dcmwrite(
            dataset=file_dataset,
            filename=level_path,
            write_like_original=False,
        )

        with ZarrIntermediate(
            None, reader.shape, zero_after_read=False
        ) as intermediate:
            reader_tile_iterator = self.reader_tile_iterator(
                reader=reader,
                num_workers=num_workers,
                intermediate=intermediate,
                read_tile_size=read_tile_size or self.tile_size,
                timeout=timeout,
            )

            def jpeg_generator(tile_iterator) -> Generator[bytes, None, None]:
                """Encodes arrays to JPEG bytes."""
                import imagecodecs

                for tile in tile_iterator:
                    yield imagecodecs.jpeg_encode(
                        tile,
                        level=self.compression_level,
                        colorspace=self.color_space,
                        outcolorspace=ColorSpace.YCBCR,
                    )


            tile_iterator = iter(
                self.level_progress(
                    jpeg_generator(reader_tile_iterator),
                    total=len(reader_tile_iterator),
                )
            )
            append_frames(level_path, tile_iterator, len(reader_tile_iterator))

            # Write pyramid resolutions
            with multiprocessing.Pool(1) as pool:  # num_workers
                for level, downsample in self.pyramid_progress(
                    enumerate(self.pyramid_downsamples),
                    total=len(self.pyramid_downsamples),
                ):
                    level += 1
                    level_shape = tuple(
                        floor(s / downsample) for s in reader.shape[:2]
                    ) + (reader.shape[-1],)

                    level_tiles_shape = mosaic_shape(
                        level_shape,
                        self.tile_size,
                    )

                    l_meta, l_dataset = create_vl_wsi_dataset(
                        size=level_shape[:2],
                        tile_size=self.tile_size,
                        microns_per_pixel=[mpp[0] * downsample, mpp[1] * downsample],
                        photometric_interpretation=photometric_interpretation,
                    )
                    l_dataset.InstanceNumber = f"{level + 1}"
                    l_dataset.StudyInstanceUID = dataset.StudyInstanceUID
                    l_dataset.SeriesInstanceUID = dataset.SeriesInstanceUID
                    l_dataset.FrameOfReferenceUID = dataset.FrameOfReferenceUID

                    level_path = str(self.path.parent / f"{self.path.stem}_{level}.dcm")
                    file_dataset = FileDataset(
                        level_path,
                        dataset=l_dataset,
                        preamble=b"\0" * 128,
                        file_meta=l_meta,
                        is_implicit_VR=False,
                        is_little_endian=True,
                    )

                    dcmwrite(
                        dataset=file_dataset,
                        filename=level_path,
                        write_like_original=False,
                    )

                    func = partial(
                        get_level_tile,
                        tile_size=self.tile_size,
                        downsample=downsample,
                        read_intermediate_path=intermediate.path,
                        downsample_method=downsample_method,
                    )

                    tile_generator = pool.imap(
                        func=func,
                        iterable=np.ndindex(level_tiles_shape),
                    )

                    tile_generator = self.level_progress(
                        tile_generator,
                        total=int(np.product(level_tiles_shape)),
                        desc=f"Level {level + 1}",
                        leave=False,
                    )

                    tile_iterator = iter(
                        self.level_progress(
                            jpeg_generator(tile_generator),
                            total=len(tile_generator),
                        )
                    )
                    append_frames(level_path, tile_iterator, len(tile_generator))

def main():


    root_folder = Path("M01KBB05R-1315")

    result_file = root_folder /  "Test"

    reader = wsic.readers.DICOMWSIReader(root_folder) 
    #writer = wsic.writers.DICOMWSIWriter(path=result_file,         
    writer = DICOMWSIWriterMultiLevel(path=result_file,                           
                                                shape=reader.original_shape[:2], 
                                                pyramid_downsamples=[2,4,8,16,32], #[2,4,8,16,32]
                                                verbose=True,
                                                compression_level=80,
                                                app_mag=40.) #   , microns_per_pixel=0.241
    writer.copy_from_reader(reader, num_workers=10, timeout=120)  #num_workers=10,

if __name__ == "__main__":
    main()