def __init__(self):
super(Root, self).__init__()
self.title("GÖRÜNTÜ İŞLEME")
self.minsize(500, 700)
self.img = data.coins()
self.img_gray = data.coins()
self.retina = data.retina()
self.moon = data.moon()
self.horse = data.horse()
self.camera = data.camera()
self.width = 50
self.imageGlobal = data.retina()
self.imageGlobal = cv2.cvtColor(self.imageGlobal, cv2.COLOR_BGR2GRAY)
self.labelFrame = tk.LabelFrame(self, text="DOSYA AÇ")
self.labelFrame.grid(column=0, row=1, padx=20, pady=20)
self.filterFrame = tk.LabelFrame(self, text="FİLTRELER")
self.filterFrame.grid(column=0, row=2, padx=20, pady=20)
self.histogramFrame = tk.LabelFrame(self, text="HİSTOGRAM EŞİTLEME")
self.histogramFrame.grid(column=0, row=3, padx=20, pady=20)
self.transformFrame = tk.LabelFrame(self, text="DÖNÜŞTÜRME İŞLEMLERİ")
self.transformFrame.grid(column=0, row=4, padx=20, pady=20)
self.videoFrame = tk.LabelFrame(self, text="VİDEO FİLTRESİ")
self.videoFrame.grid(column=0, row=5, padx=20, pady=20)
self.intensityFrame = tk.LabelFrame(self, text="YOĞUNLUK İŞLEMLERİ")
self.intensityFrame.grid(column=1, row=4, padx=20, pady=20)
self.morphologyFrame = tk.LabelFrame(self, text="MORFOLOJİK İŞLEMLER")
self.morphologyFrame.grid(column=1, row=3, padx=20, pady=20)
self.activeFrame = tk.LabelFrame(self, text="ACTİVE CONTOUR")
self.activeFrame.grid(column=1, row=1, padx=20, pady=20)
self.socialFrame = tk.LabelFrame(self, text="SOSYAL MEDYA EFEKTİ")
self.socialFrame.grid(column=1, row=2, padx=20, pady=20)
self.upload_image_button()
self.filterButton()
self.histogramButton()
self.transformButton()
self.videoButton()
self.intensityButton()
self.morphologyButton()
self.activeContourButton()
self.socialButton()
def setup(self):
retina = color.rgb2gray(data.retina())
t0, _ = filters.threshold_multiotsu(retina, classes=3)
mask = (retina > t0)
vessels = filters.sato(retina, sigmas=range(1, 10)) * mask
thresholded = filters.apply_hysteresis_threshold(vessels, 0.01, 0.03)
labeled = ndi.label(thresholded)[0]
largest_nonzero_label = np.argmax(np.bincount(labeled[labeled > 0]))
binary = (labeled == largest_nonzero_label)
self.skeleton = morphology.skeletonize(binary)
labeled2 = ndi.label(thresholded[::2, ::2])[0]
largest_nonzero_label2 = np.argmax(np.bincount(labeled2[labeled2 > 0]))
binary2 = (labeled2 == largest_nonzero_label2)
small_skeleton = morphology.skeletonize(binary2)
self.g, self.n = graph.pixel_graph(small_skeleton, connectivity=2)
def test_border_management():
img = rgb2gray(retina()[300:500, 700:900])
out = frangi(img, sigmas=[1])
full_std = out.std()
full_mean = out.mean()
inside_std = out[4:-4, 4:-4].std()
inside_mean = out[4:-4, 4:-4].mean()
border_std = np.stack(
[out[:4, :], out[-4:, :], out[:, :4].T, out[:, -4:].T]).std()
border_mean = np.stack(
[out[:4, :], out[-4:, :], out[:, :4].T, out[:, -4:].T]).mean()
assert abs(full_std - inside_std) < 1e-7
assert abs(full_std - border_std) < 1e-7
assert abs(inside_std - border_std) < 1e-7
assert abs(full_mean - inside_mean) < 1e-7
assert abs(full_mean - border_mean) < 1e-7
assert abs(inside_mean - border_mean) < 1e-7
def test_border_management(func, tol):
img = rgb2gray(retina()[300:500, 700:900])
out = func(img, sigmas=[1], mode='reflect')
full_std = out.std()
full_mean = out.mean()
inside_std = out[4:-4, 4:-4].std()
inside_mean = out[4:-4, 4:-4].mean()
border_std = np.stack(
[out[:4, :], out[-4:, :], out[:, :4].T, out[:, -4:].T]).std()
border_mean = np.stack(
[out[:4, :], out[-4:, :], out[:, :4].T, out[:, -4:].T]).mean()
assert abs(full_std - inside_std) < tol
assert abs(full_std - border_std) < tol
assert abs(inside_std - border_std) < tol
assert abs(full_mean - inside_mean) < tol
assert abs(full_mean - border_mean) < tol
assert abs(inside_mean - border_mean) < tol
def __init__(self):
super(Root, self).__init__()
self.title("Image Processor")
self.minsize(640, 400)
self.img = data.coins()
self.img_gray = data.coins()
self.retina = data.retina()
self.moon = data.moon()
self.horse = data.horse()
self.camera = data.camera()
self.width = 50
self.labelFrame = tk.LabelFrame(self, text="Open File")
self.labelFrame.grid(column=0, row=1, padx=20, pady=20)
self.filterFrame = tk.LabelFrame(self, text="Filters")
self.filterFrame.grid(column=1, row=1, padx=20, pady=20)
self.histogramFrame = tk.LabelFrame(self, text="Histogram Matching")
self.histogramFrame.grid(column=2, row=1, padx=20, pady=20)
self.transformFrame = tk.LabelFrame(self, text="Transform Operations")
self.transformFrame.grid(column=0, row=2, padx=20, pady=20)
self.videoFrame = tk.LabelFrame(
self, text="Green Filtered Video from your cam")
self.videoFrame.grid(column=1, row=2, padx=20, pady=20)
self.intensityFrame = tk.LabelFrame(self, text="Intensity Operations")
self.intensityFrame.grid(column=2, row=2, padx=20, pady=20)
self.morphologyFrame = tk.LabelFrame(self,
text="Morphological Operations")
self.morphologyFrame.grid(column=0, row=3, padx=20, pady=20)
self.upload_image_button()
self.filterButton()
self.histogramButton()
self.transformButton()
self.videoButton()
self.intensityButton()
self.morphologyButton()
def ridge_operators(): # Ridge operators meijering, sato, frangi, hessian
image = color.rgb2gray(data.retina())[300:700, 700:900]
cmap = plt.cm.gray
kwargs = {'sigmas': [1], 'mode': 'reflect'}
fig, axes = plt.subplots(2, 5)
for i, black_ridges in enumerate([1, 0]):
for j, func in enumerate([filters.meijering, filters.sato, filters.frangi, filters.hessian]):
kwargs['black_ridges'] = black_ridges
result = func(image, **kwargs)
axes[i, j].imshow(result, cmap=cmap, aspect='auto')
if i == 0:
axes[i, j].set_title(['Original\nimage', 'Meijering\nneuriteness',
'Sato\ntubeness', 'Frangi\nvesselness',
'Hessian\nvesselness'][j])
if j == 0:
axes[i, j].set_ylabel('black_ridges = ' + str(bool(black_ridges)))
axes[i, j].set_xticks([])
axes[i, j].set_yticks([])
plt.tight_layout()
plt.show()
def run():
logger.info("Starting")
file_folder = os.path.dirname(os.path.realpath(__file__))
output_folder = os.path.join(file_folder, "output")
os.makedirs(output_folder, exist_ok=True)
# Simple example with a BW test image from skimage
logger.info("Simple 512x512 example from skimage")
sc_image = SCImage()
sc_image.create_empty_iod()
sc_image.initiate()
sc_image.set_dicom_attribute("PatientName", "BWBrick^512x512")
sc_image.set_dicom_attribute("SeriesNumber", "1")
sc_image.add_pixel_data(data.brick())
study_folder = os.path.join(output_folder, "data", "sc_images")
os.makedirs(study_folder, exist_ok=True)
os.makedirs(os.path.join(study_folder, "brick_512x512"), exist_ok=True)
output_file = os.path.join(
study_folder, "brick_512x512",
str(sc_image.dataset.InstanceNumber).zfill(6) + ".dcm")
sc_image.write_to_file(output_file)
# Simple example with an RGB test image from skimage
logger.info("RGB example from skimage")
sc_image = SCImage()
sc_image.create_empty_iod()
sc_image.initiate()
sc_image.set_dicom_attribute("PatientName", "RGBRetina^NoTiling")
sc_image.set_dicom_attribute("SeriesNumber", "1")
sc_image.add_pixel_data(data.retina(), photometric_interpretation="RGB")
study_folder = os.path.join(output_folder, "data", "sc_images")
os.makedirs(study_folder, exist_ok=True)
os.makedirs(os.path.join(study_folder, "retina_no_tiling"), exist_ok=True)
output_file = os.path.join(
study_folder, "retina_no_tiling",
str(sc_image.dataset.InstanceNumber).zfill(6) + ".dcm")
sc_image.write_to_file(output_file)
def retina_speed_image():
with warnings.catch_warnings():
warnings.simplefilter('ignore', RuntimeWarning)
image_data = rescale(rgb2gray(retina())[260:1280, 90:800], 0.5)
speed_data = sato(image_data)
return speed_data
plt.figure()
plt.title(name)
if image.ndim == 2:
plt.imshow(image, cmap=plt.cm.gray)
else:
plt.imshow(image)
plt.show()
############################################################################
# Thumbnail image for the gallery
# sphinx_gallery_thumbnail_number = -1
fig, axs = plt.subplots(nrows=3, ncols=3)
for ax in axs.flat:
ax.axis("off")
axs[0, 0].imshow(data.hubble_deep_field())
axs[0, 1].imshow(data.immunohistochemistry())
axs[0, 2].imshow(data.lily())
axs[1, 0].imshow(data.microaneurysms())
axs[1, 1].imshow(data.moon(), cmap=plt.cm.gray)
axs[1, 2].imshow(data.retina())
axs[2, 0].imshow(data.shepp_logan_phantom(), cmap=plt.cm.gray)
axs[2, 1].imshow(data.skin())
further_img = np.full((300, 300), 255)
for xpos in [100, 150, 200]:
further_img[150 - 10:150 + 10, xpos - 10:xpos + 10] = 0
axs[2, 2].imshow(further_img, cmap=plt.cm.gray)
plt.subplots_adjust(wspace=-0.3, hspace=0.1)
def test_border_warning(func):
img = rgb2gray(cp.asarray(retina()[300:500, 700:900]))
with expected_warnings(["implicitly used 'constant' as the border mode"]):
func(img, sigmas=[1])
def test_output_dtype(func, dtype):
img = rgb2gray(cp.array(retina()[300:500, 700:900], dtype=dtype))
out = func(img, sigmas=[1], mode='reflect')
assert out.dtype == dtype
def retina():
retina = rgb2gray(ski_data.retina())
retina_small = resize(retina, np.array(retina.shape) // 2)
return np.pad(retina_small, 128, "constant", constant_values=0)
References
----------
.. [1] Linton C. Freeman: Centrality in networks: I.
Conceptual clarification. Social Networks 1:215-239, 1979.
:DOI:`10.1016/0378-8733(78)90021-7`
"""
import matplotlib.pyplot as plt
import numpy as np
from scipy import ndimage as ndi
from skimage import color, data, filters, graph, measure, morphology
###############################################################################
# We start by loading the data: an image of a human retina.
retina_source = data.retina()
_, ax = plt.subplots()
ax.imshow(retina_source)
ax.set_axis_off()
_ = ax.set_title('Human retina')
###############################################################################
# We convert the image to grayscale, then use the
# `Sato vesselness filter <skimage.filters.sato>` to better distinguish the
# main vessels in the image.
retina = color.rgb2gray(retina_source)
t0, t1 = filters.threshold_multiotsu(retina, classes=3)
mask = (retina > t0)
vessels = filters.sato(retina, sigmas=range(1, 10)) * mask
Computer Vision (pp. 609-622). Springer International Publishing.
:DOI:`10.1007/978-3-319-16811-1_40`
"""
from skimage import data
from skimage import color
from skimage.filters import meijering, sato, frangi, hessian
import matplotlib.pyplot as plt
def identity(image, **kwargs):
"""Return the original image, ignoring any kwargs."""
return image
image = color.rgb2gray(data.retina())[300:700, 700:900]
cmap = plt.cm.gray
kwargs = {}
kwargs['sigmas'] = [1]
fig, axes = plt.subplots(2, 5)
for i, black_ridges in enumerate([1, 0]):
for j, func in enumerate([identity, meijering, sato, frangi, hessian]):
kwargs['black_ridges'] = black_ridges
result = func(image, **kwargs)
if func in (meijering, frangi):
# Crop by 4 pixels for rendering purpose.
result = result[4:-4, 4:-4]
axes[i, j].imshow(result, cmap=cmap, aspect='auto')
if i == 0:
# In this first example, we consider the simple case of two images that only
# differ with respect to rotation around a common center point. By remapping
# these images into polar space, the rotation difference becomes a simple
# translation difference that can be recovered by phase correlation.
import numpy as np
import matplotlib.pyplot as plt
from skimage import data
from skimage.registration import phase_cross_correlation
from skimage.transform import warp_polar, rotate, rescale
from skimage.util import img_as_float
radius = 705
angle = 35
image = data.retina()
image = img_as_float(image)
rotated = rotate(image, angle)
image_polar = warp_polar(image, radius=radius, channel_axis=-1)
rotated_polar = warp_polar(rotated, radius=radius, channel_axis=-1)
fig, axes = plt.subplots(2, 2, figsize=(8, 8))
ax = axes.ravel()
ax[0].set_title("Original")
ax[0].imshow(image)
ax[1].set_title("Rotated")
ax[1].imshow(rotated)
ax[2].set_title("Polar-Transformed Original")
ax[2].imshow(image_polar)
ax[3].set_title("Polar-Transformed Rotated")
ax[3].imshow(rotated_polar)
from skimage import data
from skimage.feature import register_translation
from skimage.transform import rescale, warp_polar, rotate
from skimage.util import img_as_float
from mas.tracking import roll
import matplotlib.pyplot as plt
import numpy as np
# radius must be large enough to capture useful info in larger image
radius = 1500
angle = 53.7
scale = 2.2
image = data.retina()
image = img_as_float(image)
rotated = rotate(image, angle)
rescaled = rescale(rotated, scale, multichannel=True)
image_polar = warp_polar(image,
radius=radius,
scaling='log',
multichannel=True)
rescaled_polar = warp_polar(rescaled,
radius=radius,
scaling='log',
multichannel=True)
rescaled_polar = roll(rescaled_polar, (10, 10))
fig, axes = plt.subplots(2, 2, figsize=(8, 8))
ax = axes.ravel()
ax[0].set_title("Original")
ax[0].imshow(image)
ax[1].set_title("Rotated and Rescaled")
def run():
logger.info("Starting")
file_folder = os.path.dirname(os.path.realpath(__file__))
output_folder = os.path.join(file_folder, "output")
os.makedirs(output_folder, exist_ok=True)
# Simple example with BW noise
logger.info("Simple 256x256 example with noice")
wsm_image = WSMImage()
wsm_image.create_empty_iod()
wsm_image.initiate()
wsm_image.set_dicom_attribute("PatientName", "BWNoise^256x256")
wsm_image.set_dicom_attribute("SeriesNumber", "1")
study_folder = os.path.join(output_folder, "data", "wsm_images")
os.makedirs(study_folder, exist_ok=True)
os.makedirs(os.path.join(study_folder, "noise_256x256"), exist_ok=True)
output_file = os.path.join(
study_folder, "noise_256x256",
str(wsm_image.dataset.InstanceNumber).zfill(6) + ".dcm")
wsm_image.write_to_file(output_file)
# Simple example with a BW test image from skimage
logger.info("Simple 512x512 example from skimage")
wsm_image = WSMImage()
wsm_image.create_empty_iod()
wsm_image.initiate()
wsm_image.set_dicom_attribute("PatientName", "BWBrick^512x512")
wsm_image.set_dicom_attribute("SeriesNumber", "1")
wsm_image.add_pixel_data(data.brick())
study_folder = os.path.join(output_folder, "data", "wsm_images")
os.makedirs(study_folder, exist_ok=True)
os.makedirs(os.path.join(study_folder, "brick_512x512"), exist_ok=True)
output_file = os.path.join(
study_folder, "brick_512x512",
str(wsm_image.dataset.InstanceNumber).zfill(6) + ".dcm")
wsm_image.write_to_file(output_file)
# Simple example with a BW test image from skimage but with tiling
logger.info("Simple 512x512 example from skimage with tiling")
wsm_image = WSMImage()
wsm_image.create_empty_iod()
wsm_image.initiate()
wsm_image.set_dicom_attribute("PatientName", "BWBrick^WithTiling")
wsm_image.set_dicom_attribute("SeriesNumber", "1")
wsm_image.add_pixel_data(data.brick(), tile_size=[256, 256])
study_folder = os.path.join(output_folder, "data", "wsm_images")
os.makedirs(study_folder, exist_ok=True)
os.makedirs(os.path.join(study_folder, "brick_512x512_tiling_256x256"),
exist_ok=True)
output_file = os.path.join(
study_folder, "brick_512x512_tiling_256x256",
str(wsm_image.dataset.InstanceNumber).zfill(6) + ".dcm")
wsm_image.write_to_file(output_file)
# Simple example with an RGB test image from skimage
logger.info("RGB example from skimage")
wsm_image = WSMImage()
wsm_image.create_empty_iod()
wsm_image.initiate()
wsm_image.set_dicom_attribute("PatientName", "RGBRetina^NoTiling")
wsm_image.set_dicom_attribute("SeriesNumber", "1")
wsm_image.add_pixel_data(data.retina()[0:1410, 0:1410, :],
photometric_interpretation="RGB")
study_folder = os.path.join(output_folder, "data", "wsm_images")
os.makedirs(study_folder, exist_ok=True)
os.makedirs(os.path.join(study_folder, "retina_no_tiling"), exist_ok=True)
output_file = os.path.join(
study_folder, "retina_no_tiling",
str(wsm_image.dataset.InstanceNumber).zfill(6) + ".dcm")
wsm_image.write_to_file(output_file)
# Simple example with an RGB test image from skimage but with tiling
logger.info("RGB example from skimage with tiling")
wsm_image = WSMImage()
wsm_image.create_empty_iod()
wsm_image.initiate()
wsm_image.set_dicom_attribute("PatientName", "RGBRetina^WithTiling")
wsm_image.set_dicom_attribute("SeriesNumber", "1")
wsm_image.add_pixel_data(data.retina()[0:1410, 0:1410, :],
photometric_interpretation="RGB",
tile_size=[256, 256])
study_folder = os.path.join(output_folder, "data", "wsm_images")
os.makedirs(study_folder, exist_ok=True)
os.makedirs(os.path.join(study_folder, "retina_tiling_256x256"),
exist_ok=True)
output_file = os.path.join(
study_folder, "retina_tiling_256x256",
str(wsm_image.dataset.InstanceNumber).zfill(6) + ".dcm")
wsm_image.write_to_file(output_file)
# Simple example with an acutal WSI image with tiling and multi-resolution
logger.info(
"High resolution RGB example from pexels with tiling and multi-resolution"
)
input_file = os.path.join(file_folder, "data", "wsi_images",
"image_to_encode_as_dicom.jpg")
if not os.path.exists(input_file):
logger.info("Data not available locally, downloading")
url = "https://images.pexels.com/photos/1270184/pexels-photo-1270184.jpeg"
downloaded_file = requests.get(url)
open(input_file, "wb").write(downloaded_file.content)
im = imread(input_file)
im = im[:, :, 0:3]
study_folder = os.path.join(output_folder, "data", "wsm_images",
"BW-skull")
os.makedirs(study_folder, exist_ok=True)
patient_id = ''.join(random.choice('0123456789ABCDEF') for i in range(16))
accession_number = ''.join(
random.choice('0123456789ABCDEF') for i in range(16))
study_instance_uid = generate_uid()
series_instance_uid = generate_uid()
frame_of_reference_uid = generate_uid()
study_date = datetime.now().strftime("%Y%m%d")
study_time = datetime.now().strftime("%H%M%S")
for level in range(0, 3):
logger.info("Level: " + str(level))
wsm_image = WSMImage()
wsm_image.create_empty_iod()
wsm_image.initiate()
wsm_image.set_dicom_attribute("PatientName", "Black-White^Skull")
wsm_image.set_dicom_attribute("PatientID", patient_id)
wsm_image.set_dicom_attribute("StudyInstanceUID", study_instance_uid)
wsm_image.set_dicom_attribute("AccessionNumber", accession_number)
wsm_image.set_dicom_attribute("StudyID", accession_number)
wsm_image.set_dicom_attribute("StudyDate", study_date)
wsm_image.set_dicom_attribute("StudyTime", study_time)
wsm_image.set_dicom_attribute("SeriesInstanceUID", series_instance_uid)
wsm_image.set_dicom_attribute("FrameOfReferenceUID",
frame_of_reference_uid)
wsm_image.set_dicom_attribute("SeriesNumber", "1")
wsm_image.set_dicom_attribute("SeriesDate", study_date)
wsm_image.set_dicom_attribute("SeriesTime", study_time)
wsm_image.set_dicom_attribute("InstanceNumber", str(level))
if level > 0:
wsm_image.set_dicom_attribute(
"ImageType", ["DERIVED", "PRIMARY", "VOLUME", "RESAMPLED"])
im_resized = resize(im, (int(
im.shape[0] / pow(2, level)), int(im.shape[1] / pow(2, level)), 3),
preserve_range=True).astype(np.uint8)
wsm_image.add_pixel_data(im_resized,
photometric_interpretation="RGB",
pixel_spacing=[
0.0005 * int(pow(2, level)),
0.0005 * int(pow(2, level))
],
tile_size=[256, 256])
output_file = os.path.join(
study_folder,
str(wsm_image.dataset.InstanceNumber).zfill(6) + ".dcm")
wsm_image.write_to_file(output_file)
