File size: 4,859 Bytes
96d549d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 |
import base64
import json
import os
import cv2
import numpy
import re
import numpy as np
from PIL import Image
from abc import ABCMeta, abstractmethod
def numerical_sort(value):
numbers = re.compile(r'(\d+)')
parts = numbers.split(value)
parts[1::2] = map(int, parts[1::2])
return parts
class Slide(object):
"""
Represents a slide
"""
def __init__(self, time, img):
"""
Default initializer for a slide representation
:param time: the time when the slide appears
:param img: the image representing the slide
"""
self.time = time
self.img = img
self.marked = False
self.times = []
self.reference = None
self.page_number = 0
def add_time(self, time):
"""
Add an additional instance in time, when the slide
is displayed.
:param time: the time when the slide is displayed
"""
self.times.append(time)
def to_dict(self):
"""
Convert the Slide object to a dictionary, handling image serialization.
"""
# Convert the image to a bytes object and then encode it to a base64 string
_, buffer = cv2.imencode('.jpg', self.img)
img_encoded = base64.b64encode(buffer).decode('utf-8')
return {
'time': self.time,
'img': img_encoded, # Use the encoded image string
'marked': self.marked,
'times': self.times,
'reference': self.reference,
'page_number': self.page_number
}
@classmethod
def from_dict(cls, data):
"""
Create a Slide object from a dictionary, handling image deserialization.
"""
# Decode the image from a base64 string to a bytes object and then to a numpy array
img_decoded = base64.b64decode(data['img'])
img = cv2.imdecode(np.frombuffer(img_decoded, np.uint8), cv2.IMREAD_COLOR)
slide = cls(data['time'], img)
slide.marked = data.get('marked', False)
slide.times = data.get('times', [])
slide.reference = data.get('reference')
slide.page_number = data.get('page_number', 0)
return slide
def to_json(self):
"""
Convert the Slide object to a JSON string.
"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str):
"""
Create a Slide object from a JSON string.
"""
data = json.loads(json_str)
return cls.from_dict(data)
def slides_to_json(slides):
"""
Convert a list of Slide objects to a JSON string.
"""
return json.dumps([slide.to_dict() for slide in slides])
def slides_from_json(json_str):
"""
Create a list of Slide objects from a JSON string.
"""
slides_data = json.loads(json_str)
return [Slide.from_dict(slide_data) for slide_data in slides_data]
class SlideDataHelper(object):
"""
The helps to get slides from data.
"""
def __init__(self, path, image_type="opencv"):
"""
Default initializer
:param path: the path, where the slide is stored on disk
:image_type: the type representing the image. Either "opencv" or "pil" might be required for certain usage.
"""
self.path = path
if image_type == "pil":
self.imgreader = PILReader()
else:
self.imgreader = OpenCVReader()
def get_slides(self):
"""
Gets the slide from disk and returns them as list of "Slide"
objects.
:return: The slides stored on disk as list of "Slide" objects.
"""
slides = []
for filename in sorted(os.listdir(self.path), key=numerical_sort):
file_path = os.path.join(self.path, filename)
_, ext = os.path.splitext(file_path)
if not is_image(ext):
continue
time, _ = os.path.splitext(filename)
slide = Slide(time, self.imgreader.get_img(file_path))
slides.append(slide)
return slides
class ImageReader(object):
__metaclass__ = ABCMeta
@abstractmethod
def get_img(self, file_path):
pass
class PILReader(ImageReader):
def get_img(self, file_path):
return Image.open(file_path)
class OpenCVReader(ImageReader):
def get_img(self, file_path):
return cv2.imread(file_path)
def convert_to_opencv(img):
return cv2.cvtColor(numpy.array(img.convert('RGB')), cv2.COLOR_RGB2BGR)
def convert_to_PIL(img):
return Image.fromarray(img)
def is_image(ext):
"""
Checks if the file_format is a supported image to read.
:param ext: the extension of a file.
:return: whether or not the file is a image
"""
return ext == '.jpeg' or ext == '.png' or ext == '.jpg' or ext == '.bmp'
|