精华内容
下载资源
问答
  • 基于OpenCV的图像翻转和镜像.zip
  • 图像翻转,仿射变换 图像去雾 3D

    图像的翻转,仿射变换

    import cv2
    import numpy as np
    from matplotlib import pyplot as plt
    import math
    from skimage import util,color
    import random
    import datetime
    import pywt
    
    ## for color image show with plt
    '''
        cv读入图像与plt显示图像之间bgr->rgb的转换
    '''
    def img_plt(img):
        b,g,r = cv2.split(img)
        img = cv2.merge([r, g, b])
        return img
    
    def img_translation(img,tx,ty):
        dst_img = np.zeros((img.shape),dtype='uint8')
        for i in range(img.shape[0]):
            for j in range(img.shape[1]):
                if i+tx<dst_img.shape[0] and j+ty<dst_img.shape[1]:
                   dst_img[i+tx][j+ty] = img[i][j]
        return dst_img
    
    def img_resize(img,sx,sy):
        if len(img.shape)<=2:
            dst_img = np.zeros((round(img.shape[0]*sx),round(img.shape[1]*sy)),dtype='uint8')
        else:
            dst_img = np.zeros((round(img.shape[0] * sx), round(img.shape[1] * sy),img.shape[2]), dtype='uint8')
        for i in range(dst_img.shape[0]):
            for j in range(dst_img.shape[1]):
                if round(i/sx) < img.shape[0] and round(j/sy) < img.shape[1]:
                    dst_img[i][j] = img[round(i/sx)][round(j/sy)]
        return dst_img
    
    def img_rotation(img,th):
        dst_img = np.zeros((img.shape), dtype='uint8')
        row = img.shape[0]
        col = img.shape[1]
        # x = x'cos(theta)-y'sin(theta) + m/2*(1-cos(theta))+n/2*sin(theta)
        # y = x'sin(theta)+y'cos(theta) + n/2*(1-cos(theta))-m/2*sin(theta)
        for i in range(row):
            for j in range(col):
                m = i*math.cos(th)-j*math.sin(th)+row/2*(1-math.cos(th))+col/2*math.sin(th)
                n = i*math.sin(th)+j*math.cos(th)+col/2*(1-math.cos(th))-row/2*math.sin(th)
                if m >=0 and m < row and n >=0 and n<col:
                    dst_img[i][j] = img[math.floor(m)][math.floor(n)]
        return dst_img
    
    # 最近邻插值算法
    # dst_h为新图的高;dst_w为新图的宽
    def NN_interpolation(img,dst_h,dst_w):
        scr_h = img.shape[0]
        scr_w = img.shape[1]
        if len(img.shape)>2:
            dst_img=np.zeros((dst_h,dst_w,img.shape[2]),dtype=np.uint8)
        else:
            dst_img = np.zeros((dst_h, dst_w), dtype=np.uint8)
        for i in range(dst_h):
            for j in range(dst_w):
                scr_x=round(i*(scr_h/dst_h))
                scr_y=round(j*(scr_w/dst_w))
                if scr_x < scr_h and scr_y < scr_w:
                    dst_img[i,j]=img[scr_x,scr_y]
        return dst_img
    
    ## 双线性插值
    def bilinear_interpolation(img, dst_h,dst_w):
        src_h = img.shape[0]
        src_w = img.shape[1]
        if src_h == dst_h and src_w == dst_w:
            return img.copy()
        if len(img.shape) > 2:
            dst_img = np.zeros((dst_h, dst_w, img.shape[2]), dtype=np.uint8)
        else:
            dst_img = np.zeros((dst_h, dst_w), dtype=np.uint8)
        scale_x, scale_y = float(src_h) / dst_h, float(src_w) / dst_w
        for dstx in range(dst_h):
            for dsty in range(dst_w):
    
                # find the origin x and y coordinates of dst image x and y
                # use geometric center symmetry
                # if use direct way, src_x = dst_x * scale_x
                srcy = (dsty + 0.5) * scale_y - 0.5  # yp  y'
                srcx = (dstx + 0.5) * scale_x - 0.5  # xp  x'
    
                # find the coordinates of the points which will be used to compute the interpolation
                src_y0 = int(math.floor(srcy))       # j
                src_y1 = min(src_y0 + 1, src_w - 1)   # j+1
                src_x0 = int(math.floor(srcx))       # i
                src_x1 = min(src_x0 + 1, src_h - 1)   # i+1
                ##  A(i,j) B(i+1,j)  C(i,j+1)  D(i+1,j+1)
                if src_x0 != src_x1 and src_y1 != src_y0:
                    ### calculate the interpolation
                    ge = ((src_x1 - srcx) * img[src_x0, src_y0] + (srcx - src_x0) * img[src_x1, src_y0]) / (src_x1 - src_x0)
                    gf = ((src_x1 - srcx) * img[src_x0, src_y1] + (srcx - src_x0) * img[src_x1, src_y1] )/ (src_x1 - src_x0)
                    dst_img[dstx, dsty] = ((src_y1 - srcy) * ge + (srcy - src_y0) * gf) / (src_y1 - src_y0)
        return dst_img
    
    if __name__ == '__main__':
        #####  Image correction
        ### warpAffine
        # cv2.flip()                                   # 图像翻转
        # cv2.warpAffine()                             # 图像仿射
        # cv2.getRotationMatrix2D()                    #取得旋转角度的Matrix
        # cv2.GetAffineTransform(src, dst, mapMatrix)  #取得图像仿射的matrix
        # cv2.getPerspectiveTransform(src, dst)        #取得图像透视的4个点起止值
        # cv2.warpPerspective()                        #图像透视
    
        ###  Gray interpolation
        # img = cv2.imread('lena-color.jpg')
        # dst_NN = NN_interpolation(img, 1024,1024)
        # dst_bi = bilinear_interpolation(img, 1024,1024)
        # img = img_plt(img)
        # dst_NN = img_plt(dst_NN)
        # dst_bi = img_plt(dst_bi)
        # dif = dst_NN - dst_bi
        # plt.figure(1)
        # plt.subplot(221),plt.xlabel("original image"),plt.imshow(img)
        # plt.subplot(222),plt.xlabel("NN interpolation"), plt.imshow(dst_NN)
        # plt.subplot(223),plt.xlabel("Bilinear interpolation"), plt.imshow(dst_bi)
        # plt.subplot(224), plt.xlabel("Dif with NN and Bi"), plt.imshow(dif)
        # plt.show()
        ##### Image Inpaint with opencv
        ## get the mask image
        # img1 = cv2.imread('lena-color-need-process.png')
        # img2 = cv2.imread('lena-color.jpg')
        # mask_img = img1-img2
        # for i in range(mask_img.shape[0]):
        #     for j in range(mask_img.shape[1]):
        #         if mask_img[i,j,0] != 0 and mask_img[i,j,1] != 0 and mask_img[i,j,2] != 0:
        #             mask_img[i,j,:] = 255
        # cv2.imwrite('lena-color-mask.png',mask_img)
        #### image inpaint
        img1 = cv2.imread('lena-color-need-process.png')
        mask_img = cv2.imread('lena-color-mask.png')
        mask_img = cv2.cvtColor(mask_img, cv2.COLOR_BGR2GRAY)
        dst_TELEA = cv2.inpaint(img1, mask_img, 3, cv2.INPAINT_TELEA)
        dst_NS = cv2.inpaint(img1, mask_img, 3, cv2.INPAINT_NS)
        img1 = img_plt(img1)
        dst_TELEA = img_plt(dst_TELEA)
        dst_NS = img_plt(dst_NS)
        plt.figure(1)
        plt.xlabel("Image patching")
        plt.subplot(221),plt.xlabel("degraded image"),plt.imshow(img1)
        plt.subplot(222), plt.xlabel("mask image"), plt.imshow(mask_img,cmap = 'gray')
        plt.subplot(223),plt.xlabel("TELEA"),plt.imshow(dst_TELEA)
        plt.subplot(224), plt.xlabel("NS"), plt.imshow(dst_NS)
    
    
        img = cv2.imread('lena-color.jpg')
        img = img_plt(img)
        plt.figure(2)
        plt.imshow(img)  # 显示原图像
        plt.show()
    

    图像去雾

    import cv2
    import numpy as np
    from matplotlib import pyplot as plt
    import math
    
    
    ###  最小值滤波,r是滤波器半径
    def zmMinFilterGray(src, r=7):
        ###  腐蚀操作  模板中心点的像素值为:模板覆盖区域内所有像素中的最小的值
        return cv2.erode(src, np.ones((2 * r + 1, 2 * r + 1)))
    
    ###  基于引导滤波的大气光估计,I输入暗通道图像,p引导图像为,eps精度参数
    def guidedfilter(m,I, p, r, eps):
        height, width = I.shape
        m_I = cv2.boxFilter(I, -1, (r, r))        ## 线性滤波器:默认均值滤波
        m_p = cv2.boxFilter(p, -1, (r, r))
        m_Ip = cv2.boxFilter(I * p, -1, (r, r))
        cov_Ip = m_Ip - m_I * m_p
    
        m_II = cv2.boxFilter(I * I, -1, (r, r))
        var_I = m_II - m_I * m_I
    
        a = cov_Ip / (var_I + eps)
        b = m_p - a * m_I
    
        m_a = cv2.boxFilter(a, -1, (r, r))
        m_b = cv2.boxFilter(b, -1, (r, r))
        V1 = m_a * I + m_b
    
        ### 计算大气光照A
        bins = 2000
        ht = np.histogram(V1, bins)                  # histogram
        d = np.cumsum(ht[0]) / float(V1.size)        # Cumulative histogram
        for lmax in range(bins - 1, 0, -1):
            if d[lmax] <= 0.999:
                break
        A = np.mean(m, 2)[V1 >= ht[1][lmax]].max()  #依据V1,估计大气光值
    
        return V1,A         #滤波输出图像 通过引导滤波得到的大气耗散 V(x)模糊版本
    
    ###  w透射率权重  maxV1灰度最大值
    def Defog(m, r, eps, w, maxV1):                 # 输入rgb图像,值范围[0,1]
        ###计算大气遮罩图像V1和光照值A, V1 = 1-t/A
        V1 = np.min(m, 2)                           # 得到暗通道图像
    
        Dark_Channel = zmMinFilterGray(V1, 7)      #  最小值滤波
    
        V1,A = guidedfilter(m,V1, Dark_Channel, r, eps)  # 使用引导滤波优化
    
        V1 = np.minimum(V1 * w, maxV1)               # 对值范围进行限制
        return V1, A
    
    ###
    ###  r 代表反射率
    def deHaze(m, r=81, eps=0.001, w=0.95, maxV1=0.80, bGamma=False):
        Y = np.zeros(m.shape)
        Mask_img, A = Defog(m, r, eps, w, maxV1)             # 得到遮罩图像和大气光照
    
        for k in range(3):
            Y[:,:,k] = (m[:,:,k] - Mask_img)/(1-Mask_img/A)  # 颜色校正
        Y = np.clip(Y, 0, 1)
        if bGamma:
            Y = Y ** (np.log(0.5) / np.log(Y.mean()))       # gamma校正,默认不进行该操作
        return Y
    
    ## for color image show with plt
    def img_plt(img):
        b,g,r = cv2.split(img)
        img = cv2.merge([r, g, b])
        return img
    
    if __name__ == '__main__':
        img = cv2.imread('fog0.jpg')
        m = np.uint8(deHaze(img / 255.0) * 255)  # deHaze输入值范围[0,1]
    
        plt.subplot(121),plt.imshow(img)
        plt.title('Input Image'), plt.xticks([]), plt.yticks([])
        plt.subplot(122),plt.imshow(m)
        plt.title('Defog result'), plt.xticks([]), plt.yticks([])
        plt.show()
    

    3D

    import numpy as np
    import pandas as pd
    import cv2
    import numpy as np
    from skimage.draw import ellipsoid
    import matplotlib.pyplot as plt
    from skimage import measure, morphology
    from mpl_toolkits.mplot3d.art3d import Poly3DCollection
    
    if __name__ == '__main__':
        # Generate a level set about zero of two identical ellipsoids in 3D
        ellip_base = ellipsoid(6, 10, 16, levelset=True)
        ellip_double = np.concatenate((ellip_base[:-1, ...],
                                       ellip_base[2:, ...]), axis=0)
    
        # Use marching cubes to obtain the surface mesh of these ellipsoids
        verts, faces, normals, values = measure.marching_cubes_lewiner(ellip_double, 0)
    
        # Display resulting triangular mesh using Matplotlib. This can also be done
        # with mayavi (see skimage.measure.marching_cubes_lewiner docstring).
        fig = plt.figure(figsize=(10, 10))
        ax = fig.add_subplot(111, projection='3d')
    
        # Fancy indexing: `verts[faces]` to generate a collection of triangles
        mesh = Poly3DCollection(verts[faces])
        mesh.set_edgecolor('k')
        ax.add_collection3d(mesh)
    
        ax.set_xlabel("x-axis: a = 6 per ellipsoid")
        ax.set_ylabel("y-axis: b = 10")
        ax.set_zlabel("z-axis: c = 16")
    
        ax.set_xlim(0, 24)  # a = 6 (times two for 2nd ellipsoid)
        ax.set_ylim(0, 20)  # b = 10
        ax.set_zlim(0, 32)  # c = 16
    
        plt.tight_layout()
        plt.show()
    

    在这里插入图片描述

    添加水印

    添加字体水印

    import cv2
    import numpy as np
    from matplotlib import pyplot as plt
    from PIL import Image, ImageDraw, ImageFont
    
    ####水印
    ###添加字体
    # im = Image.open("lena-color.jpg").convert('RGBA')
    # #新建一个空白图片,尺寸与打开图片一样
    # txt=Image.new('RGBA', im.size, (0,0,0,0))
    # #设置字体
    # fnt=ImageFont.truetype("c:/Windows/Fonts/Tahoma.ttf", 40)
    # #操作新建的空白图片>>将新建的图片添入画板
    # d=ImageDraw.Draw(txt)
    # #在新建的图片上添加字体
    # d.text((txt.size[0]-115,txt.size[1]-80), "cnBlogs",font=fnt, fill=(255,255,255,50))
    # #合并两个图片
    # out=Image.alpha_composite(im, txt)
    # out.show()
    
    def add_text_to_image(image, text):
        font = ImageFont.truetype('C:\Windows\Fonts\STXINGKA.TTF', 36)
    
        # 添加背景
        new_img = Image.new('RGBA', (image.size[0] * 3, image.size[1] * 3), (0, 0, 0, 0))
        new_img.paste(image, image.size)
    
        # 添加水印
        font_len = len(text)
        rgba_image = new_img.convert('RGBA')
        text_overlay = Image.new('RGBA', rgba_image.size, (255, 255, 255, 0))
        image_draw = ImageDraw.Draw(text_overlay)  ##创建一个可以在给定图像上绘图的对象
    # 多水印添加
        for i in range(0, rgba_image.size[0], font_len * 40 + 100):
            for j in range(0, rgba_image.size[1], 200):
                ####
                image_draw.text((i, j), text, font=font, fill=(0, 0, 0, 50))
        text_overlay = text_overlay.rotate(-45)     ##方向
        image_with_text = Image.alpha_composite(rgba_image, text_overlay)
    
        # 裁切图片
        image_with_text = image_with_text.crop((image.size[0], image.size[1], image.size[0] * 2, image.size[1] * 2))
        return image_with_text
    
    
    if __name__ == '__main__':
        img = Image.open("lena-color.jpg")
        im_after = add_text_to_image(img, '测试使用')
        im_after.show()
    
    
    

    添加图片水印

    ##添加小图片水印
    im = Image.open("lena-color.jpg")
    mark=Image.open("mask.jpg")
    layer=Image.new('RGBA', im.size, (0,0,0,0))
    ##paste函数的参数为(需要修改的图片,粘贴的起始点的横坐标,粘贴的起始点的纵坐标)
    layer.paste(mark, (int(im.size[0]/3),int(im.size[1]/3)))
    out=Image.composite(layer,im,layer)
    out.show()
    
    # PIL的alpha_composite(im1,im2) 图像通道融合
    # im2要和im1的size和mode一致,且要求格式为RGBA
    im1 = Image.open("lena-color.jpg")
    im2 = Image.open("mask.jpg")
    layer=Image.new('RGBA', im1.size, (0,0,0,0))
    layer.paste(im2, (int(im1.size[0]/3),int(im1.size[1]/3)))
    im1=im1.convert("RGBA")
    newim1 = Image.alpha_composite(im1,layer) # 将im2合成到im1中,如果其一是透明的,
    # 才能看到结果,不然最终结果只会显示出im2
    newim1.show()
    #print(im1.mode)
    
    # -----------------------------------------
    # image.blend(im1,im2,alpha)
    # alpha为透明度
    newim2 = Image.blend(im1,layer,0.5)
    newim2.show()
    
    ####  视频处理
    vidcap = cv2.VideoCapture('test.mov')
    #获得码率及尺寸
    fps = vidcap.get(cv2.CAP_PROP_FPS)
    size = (int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH)),
            int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
    count = 0
    # cv2.namedWindow('input_image', cv2.WINDOW_AUTOSIZE)
    success,image = vidcap.read()
    while success:
      # cv2.imshow('frame',image)
      # cv2.waitKey(0)
      cv2.imwrite("./frame/frame%d.jpg" % count, image)  # save frame as JPEG file
      if cv2.waitKey(10) == 27:
          break
      count += 1
      success, image = vidcap.read()
    # cv2.destroyAllWindows()
    
    # 高斯金字塔
    def pyramid_image(image):
        level = 3  # 金字塔的层数
        temp = image.copy()  # 拷贝图像
        pyramid_images = []
        for i in range(level):
            dst = cv2.pyrDown(temp)
            pyramid_images.append(dst)
            cv2.imshow("gussian" + str(i), dst)
            temp = dst.copy()
        return pyramid_images
    
    
    # 拉普拉斯金字塔
    def laplian_image(image):
        pyramid_images = pyramid_image(image)
        level = len(pyramid_images)
        for i in range(level - 1, -1, -1):
            if (i - 1) < 0:
                expand = cv2.pyrUp(pyramid_images[i], dstsize=image.shape[:2])
                lpls = cv2.subtract(image, expand)
                cv2.imshow("lap" + str(i), lpls)
            else:
                expand = cv2.pyrUp(pyramid_images[i], dstsize=pyramid_images[i - 1].shape[:2])
                lpls = cv2.subtract(pyramid_images[i - 1], expand)
                cv2.imshow("lap" + str(i), lpls)
    
    
    src = cv2.imread("lena-color.jpg")
    cv2.imshow("input image", src)
    pyramid_image(src)
    # laplian_image(src)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    
    
    展开全文
  • from torch.utils.data import Dataset, DataLoader import numpy as np import SimpleITK as sitk ...class My_MR_Dataset(Dataset): """ 下载数据、初始化数据,都可以在这里完成 """ def __init__(sel...
    
    from torch.utils.data import Dataset, DataLoader
    import numpy as np
    import SimpleITK as sitk
    import os
    
    class My_MR_Dataset(Dataset):
        """
            下载数据、初始化数据,都可以在这里完成
        """
    
        def __init__(self, src_folder, params):
            self.params = params
            self.src_folder = src_folder
    
            self.loadTrainingData()
            self.images_numpy = self.getNumpyImages()
            self.gt_numpy = self.getNumpyGt()
    
            assert len(self.images_numpy) == len(self.gt_numpy)
    
            self.len = len(self.images_numpy)
    
        def __getitem__(self, index):
            return self.images_numpy[list(self.images_numpy.keys())[index]], self.gt_numpy[list(self.gt_numpy.keys())[index]]
    
        def __len__(self):
            return self.len
    
        def get_new_spacing(self, sitkImage, new_size):
    
            center = np.array(sitkImage.GetOrigin())
            old_size = np.array(sitkImage.GetSize())
            old_spacing = np.array(sitkImage.GetSpacing())
            new_size[-1] = old_size[-1]
    
            x_rate = 0.45
            y_rate = 0.45
    
            old_size[0] = old_size[0] * x_rate
            old_size[1] = old_size[1] * y_rate
    
            new_spacing = ((old_size * old_spacing + center) - center) / new_size
            new_spacing[-1] = old_spacing[-1]
    
            return new_spacing
    
        def getNumpyImages(self):
            data = self.getNumpyData(self.sitk_images, sitk.sitkLinear)
            return data
    
        def getNumpyGt(self):
            data = self.getNumpyData(self.sitk_gt, sitk.sitkLinear)
            for key in data:
                data[key] = (data[key]>0.5).astype(dtype=np.float32)
            return data
    
        def getNumpyData(self, data, method):
            '''
            # 要与mhd.py中的read_mhd函数共同修改
            :param data: sitk_images
            :param method:
            :return:
            '''
    
            ret = dict()
            self.sitkImage = dict()
            for key in data:
    
                ret[key] = np.zeros([self.params['VolSize'][0], self.params['VolSize'][1], self.params['VolSize'][2]],
                                    dtype=np.float32)  # 占位
                self.params['dstRes'] = self.get_new_spacing(data[key], self.params['VolSize'])  # 求新尺寸下的spacing
                img = data[key]
                spacing = img.GetSpacing()
                # one of the image's spacing is 6
                if (spacing[2] == 6):
                    spacing = (spacing[0], spacing[1], 3)
    
                factor = np.asarray(spacing) / [self.params['dstRes'][0], self.params['dstRes'][1],
                                                self.params['dstRes'][2]]  # old spacing和new spacing之比
                factor_size = np.asarray(img.GetSize() * factor, dtype=float)
                new_size = np.max([factor_size, self.params['VolSize']], axis=0)  # 这是先把原图原封不动地读出来,然后在原图的基础上裁剪
                new_size = new_size.astype(dtype=int)
    
                T = sitk.AffineTransform(3)  # 仿射变换:相当于对于图像做了一个平移、旋转、放缩、剪切、对称。与刚体变换相同的是,可以保持线点之间的平行和共线关系。
                T.SetMatrix(img.GetDirection())  # ???
    
                resampler = sitk.ResampleImageFilter()  # Resample an image via a coordinate transform,就是对img的一系列操作
                resampler.SetReferenceImage(img)  # This methods sets the output size, origin, spacing and direction to
                # that of the provided image
                resampler.SetOutputSpacing([self.params['dstRes'][0], self.params['dstRes'][1], self.params['dstRes'][2]])
                resampler.SetSize(new_size.tolist())
                resampler.SetInterpolator(method)  # 线性插值
    
                if self.params['normDir']:
                    resampler.SetTransform(T.GetInverse())  # 图像翻转
    
                '''
                Organ = img.GetOrigin()
                imDepth = img.GetDepth() * img.GetSpacing()[2]
                outputDepth = self.params['dstRes'][2] * self.params['VolSize'][2]
    
                if imDepth > outputDepth:
                    deltaDepth = np.round((imDepth - outputDepth) / 2 / img.GetSpacing()[2]) * img.GetSpacing()[2]
                    Organ = [Organ[0], Organ[1], Organ[2] - deltaDepth]
                    resampler.SetOutputOrigin(Organ)
                '''
                img_resampled = resampler.Execute(img)
    
                img_centroid = np.asarray(new_size, dtype=float) / 2.0  # img中心点坐标
                img_start_px = (img_centroid - self.params['VolSize'] / 2.0).astype(dtype=int)  # 裁剪框左上角起始点
                img_start_px[1] = img_start_px[1] * 0.5  # 将裁剪框从中央向上移动一点
                # 提取一个感兴趣的区域,其实就是裁剪一个区域
                region_extractor = sitk.RegionOfInterestImageFilter()
                region_extractor.SetSize(self.params['VolSize'].tolist())  # 截取region的大小,和VolSize一样大
                region_extractor.SetIndex(img_start_px.tolist())  # 截取region的起始点
                img_resampled_cropped = region_extractor.Execute(img_resampled)
    
                self.sitkImage[key] = img_resampled_cropped
                ret[key] = sitk.GetArrayFromImage(img_resampled_cropped).astype(dtype=float)
            return ret
    
        def loadTrainingData(self):
            self.createImageFileList()
            self.createGTFileList()
            self.loadImages()
            self.loadGT()
    
        def createGTFileList(self):
            self.gt_list = list()
            for f in self.file_list:
                filename, ext = os.path.splitext(f)
                self.gt_list.append(os.path.join(filename + '_segmentation' + ext))
    
        def createImageFileList(self):
            self.file_list = [f for f in os.listdir(self.src_folder)
                                if os.path.isfile(os.path.join(self.src_folder, f)) and 'segmentation' not in f and 'raw' not in f ]
            print('File List:' + str(self.file_list))
    
        def loadImages(self):
            self.sitk_images = dict()
            rescal_filt = sitk.RescaleIntensityImageFilter()
            rescal_filt.SetOutputMaximum(1)
            rescal_filt.SetOutputMinimum(0)
    
            stats = sitk.StatisticsImageFilter()
            m = 0.
            for f in self.file_list:
                self.sitk_images[f] = rescal_filt.Execute(
                    sitk.Cast(sitk.ReadImage(os.path.join(self.src_folder, f)), sitk.sitkFloat32))
                stats.Execute(self.sitk_images[f])
                m += stats.GetMean()
    
            self.mean_intensity_train = m / len(self.sitk_images)
    
        def loadGT(self):
            self.sitk_gt = dict()
            for f in self.gt_list:
                self.sitk_gt[f] = sitk.Cast(sitk.ReadImage(os.path.join(self.src_folder, f))>0.5, sitk.sitkFloat32)
    
    
    if __name__ == '__main__':
    
        ##########################################################################################
        #
        #   注意
        #   1、此代码仅仅截取MR图像中的膀胱部分;
        #   2、batch_size指病人样本个数。但是由于每个病人样本的切片数不一样,
        #   不能将不同切片数的病人放入一个batch中,导致batch size只能设置1。
        #
        ##########################################################################################
    
        src_folder = '/home/zhangxuchang/laboratory/changv-net/data/test'
        params = dict()
        params['VolSize'] = np.asarray([128, 128, 64], dtype=int)
        params['normDir'] = False  # if rotates the volume according to its transformation in the mhd file. Not reccommended.
                                                            # 即图像翻转用的,暂时不考虑
    
        my_mr_dataset = My_MR_Dataset(src_folder, params)
        train_loader = DataLoader(dataset=my_mr_dataset,
                                   batch_size=1, # 只能为1
                                   shuffle=True)
    
        for i, data in enumerate(train_loader):
            images, gt = data # torch.Tensor[batch, slice, x, y]
            print (np.shape(images))
            print(np.shape(gt))
            print ()
    
    
    展开全文
  • 图像处理的常见操作包括图像显示,基本操作如裁剪,翻转,旋转等,图像分割,分类和特征提取,图像恢复和图像识别。Python是图像处理的合适选择,因为它作为一种科学编程语言日益普及,并且提供了许多免费实用的图像...

    介绍

    如今的世界存在了大量的数据,图像数据是重要的组成部分。如果要利用这些图片,需要对图像进行处理,提高图片质量或提取图片内容信息。

    图像处理的常见操作包括图像显示,基本操作如裁剪,翻转,旋转等,图像分割,分类和特征提取,图像恢复和图像识别。Python是图像处理的合适选择,因为它作为一种科学编程语言日益普及,并且提供了许多免费实用的图像处理工具。

    下面将介绍10个用于图像处理的python库,它们在处理图像等方面都提供了简单方便的方法。

    1. scikit Image

    scikit-image(https://scikit-image.org/)是一个与numpy一起使用的开源Python工具。它实现了用于研究,教育和行业应用的算法和实用程序。即使是刚接触Python的人也可以轻松使用。它的代码由活跃的志愿者编写,由高质量的同行进行评审。

    资源

    有完善的文档和丰富的示例(http://scikit-image.org/docs/stable/user_guide.html)。

    示例

    导入skimage,大多数函数都在它的子模块中。下面是一些 skimage 的例子:

    • 图像过滤

    import matplotlib.pyplot as plt 
    %matplotlib inline
    
    from skimage import data,filters
    
    image = data.coins()
    # ... 或者其他的 Numpy 数组
    edges = filters.sobel(image)
    plt.imshow(edges, cmap='gray')
    

    640?wx_fmt=png

    • 使用match_template函数进行模板匹配

    640?wx_fmt=png

    在gallery中有更多例子。

    2. Numpy

    Numpy是Python的核心库之一,它为数组提供了支持。一个图像本质上是包含像素数据的标准Numpy数组。因此,通过使用基本的Numpy操作,例如切片,掩膜(mask)和花式索引(fancy indexi)等直接修改图像的像素值。可以使用skimage加载图像并用matplotlib显示。

    资源

    Numpy的官方文档提供了完整的文档和资源列表(http://www.numpy.org/)。

    示例

    使用Numpy对图像进行掩膜操作。

    import numpy as np
    from skimage import data
    import matplotlib.pyplot as plt 
    %matplotlib inline
    
    image = data.camera()
    type(image)
    
    numpy.ndarray #图像是一个numpy数组
    
    mask = image &lt; 87
    image[mask]=255
    plt.imshow(image, cmap='gray')
    

    640?wx_fmt=png

    3. Scipy

    scipy是一个类似Numpy的核心科学计算模块,可用于基本的图像处理任务。特别是子模块scipy.ndimage提供了操作n维Numpy数组的函数。该软件包目前包括线性、非线性滤波,二值形态(binary morphology),B样条插值(B-spline interpolatio)和对象测量(object measurements)等功能。

    资源

    scipy.ndimage的完整函数列表:https://docs.scipy.org/doc/scipy/reference/tutorial/ndimage.html#correlation-and-convolution

    示例

    SciPy高斯过滤:

    from scipy import misc,ndimage
    
    face = misc.face()
    blurred_face = ndimage.gaussian_filter(face, sigma=3)
    very_blurred = ndimage.gaussian_filter(face, sigma=5)
    
    #Results
    plt.imshow(&lt;image to be displayed&gt;)
    

    640?wx_fmt=png

    4. PIL / Pillow

    PIL(Python Imaging Library)是一个免费的Python函数库,它增加了打开、操作和保存多种不同图像格式的支持。然而,它已经停止了开发,最后一次发布是2009年。幸运的是,PIL有一个活跃的分支Pillow,它更易于安装,支持所有主要的操作系统并支持Python 3。该库包含了基本的图像处理功能,包括像素操作,使用内置卷积内核进行过滤以及颜色空间转换。

    资源

    该文档包含了安装指引以及每个模块的示例。

    示例

    使用Pillow中的ImageFilter增强图像:

    from PIL import Image, ImageFilter
    #读入图像
    im = Image.open( 'image.jpg' )
    #显示图像
    im.show()
    
    from PIL import ImageEnhance
    enh = ImageEnhance.Contrast(im)
    enh.enhance(1.8).show("30% more contrast")
    

    640?wx_fmt=png

    5. OpenCV-Python

    OpenCV(Open Source Computer Vision Library)是视觉应用中使用最广的库之一。OpenCV-Python是OpenCV的python API。OpenCV-Python不仅速度快,因为后台使用C/C++编写,而且易于编码和部署(由于前端的Python包装器)。这使其成为执行计算密集型视觉程序的绝佳选择。

    资源

    OpenCV2-Python-Guide使你更容易上手OpenCV-Python。

    示例

    下面的示例是使用OpenCV-Python的金字塔融合创建名为'Orapple'的新水果的功能。

    640?wx_fmt=jpeg

    6. SimpleCV

    SimpleCV也是一个构建视觉应用的开源框架。有了它,您可以使用如OpenCV等几个高性能的计算机视觉库,不需要了解位深度,文件格式,色彩空间等概念。学习难度远远小于OpenCV,并且正如他们的标语所说,“它使计算机视觉变得简单”。SimpleCV的其他优点还有:

    • 初学者也可以编写简单的机器视觉测试

    • 摄像机,视频文件,图像和视频流可以相互操作

    资源

    官方文档简单易懂,还有大量的案例参考。

    示例

    640?wx_fmt=png

    7. Mahotas

    Mahotas是另一个Python计算机视觉和图像处理库。它包含了传统的图像处理功能,如过滤和形态学操作,以及用于特征计算的计算机视觉功能,包括兴趣点检测和局部描述符。该接口使用Python,可以快速开发,算法使用C++实现,并且针对速度进行了优化。Mahotas库具有尽量少的代码甚至最小的依赖。阅读他们的{官方文章](https://openresearchsoftware.metajnl.com/articles/10.5334/jors.ac/)获取更多信息。

    资源

    该文档包含了安装说明,示例和教程,帮助你轻松地使用mahotas。

    示例

    Mahotas尽量使用简单的代码实现功能。例如“Finding Wally”问题,Mahotas使用最少的代码实现了较好的结果。这里是它的源代码。

    640?wx_fmt=png

    640?wx_fmt=png

    8. SimpleITK

    ITK(Insight Segmentation and Registration Toolkit)是一个开源的跨平台系统,为开发人员提供了一整套用于图像分析的软件工具。其中,SimpleITK是一个基于ITK的简化层,旨在促进快速原型设计,教育,解释语言中的使用。SimpleITK是一个图像分析工具包,具有大量的组件,支持过滤操作,图像分割和配准。SimpleITK使用C++编写,也可以用于包括Python在内的大量编程语言。

    资源

    有许多Jupyter Notebooks展示了SimpleITK在教育和研究中的使用。使用SimpleITK进行Python和R编程语言的交互式图像分析。

    示例

    下面是使用SimpleITK和Python实现的CT/MR配准过程的可视化。源代码。

    640?wx_fmt=gif

    9. pgmagick

    pgmagick是使用Python包装的GraphicsMagick库。GraphicsMagick有时被称为图像处理中的瑞士军刀。它提供了强大高效的工具和库集合,支持超过88种主要图像格式的读取,写入和操作,包括DPX,GIF,JPEG,JPEG-2000,PNG,PDF,PNM和TIFF等重要格式。

    资源

    Github仓库,有安装和要求说明,详细的用户指南。

    示例

    一些使用 pgmagick 的图像操作:

    图像缩放:

    640?wx_fmt=png

    边缘提取:

    640?wx_fmt=png

    10. Pycairo

    Pycairo是cairo图形库的一组python绑定。Cairo是一个绘制矢量图形的2D图形库。矢量图形在调整大小或变换时不会丢失清晰度。Pycairo可使用Python调用cairo命令。

    资源

    Pycairo GitHub仓库有安装和使用的详细说明。以及Pycairo的简要教程。

    示例

    使用Pycairo绘制线段,基本形状和径向渐变(radial gradients)。

    640?wx_fmt=png

    总结

    以上是Python中一些好用且免费的图像处理库。他们都值得尝试使用并了解更多它们的信息。

     

     

    欢迎关注磐创博客资源汇总站:
    http://docs.panchuang.net/

    欢迎关注PyTorch官方中文教程站:
    http://pytorch.panchuang.net/

    展开全文
  • 基于python图像处理API

    万次阅读 2020-04-02 11:19:20
    常用的图像处理技术有图像读取,写入,绘图,图像色彩空间转换,图像几何变换,图像形态学,图像梯度,图像边缘检测,图像轮廓,图像分割,图像去噪,图像加水印以及修复水印等 2.opencv常用的接口 cv.imread()...

    1.图像处理库

    import cv2 as cv
    from PIL import *

    常用的图像处理技术有图像读取,写入,绘图,图像色彩空间转换,图像几何变换,图像形态学,图像梯度,图像边缘检测,图像轮廓,图像分割,图像去噪,图像加水印以及修复水印等

    2.opencv常用的接口

    cv.imread()
        读取图片,返回numpy
    cv.imwrite()   
        写入图片
    cv.cvtColor()   
        图像色彩空间转换
    cv.add()
    cv.subtract()
    cv.multiply()
    cv.divide()
    cv.applyColorMap()
        减少了运算量,改变图片风格,突出图片特征
    cv.bitwise_and(参数1, 参数2)
        逻辑与
    cv.bitwise_xor(参数1, 参数2)
        逻辑异或
    cv.bitwise_or(参数1, 参数2)
        逻辑或
    cv.bitwise_not(参数)
        图像值取反操作
    cv.split(src)   
        通道分离
    cv.merge(mv)
        通道合并
    cv2.inRange(hsv, lower, upper)   
        提取指定色彩范围区域inRange
    cv.meanStdDev()   
        均值和标准差
    cv.minMaxLoc()
        最大最小值和相应的位置
    cv.normalize()
        像素归一化
    cv.VideoCapture()
        视频文件
    cv.flip(src,flipcode,dst)
        图像翻转
    cv.rectangle()   
        矩形
    cv.circle()
        圆
    cv.ellipse()
        椭圆
    cv.calcHist()
        图像直方图
    cv.equalizeHist()
        图像直方图均衡化可以用于图像增强、对输入图像进行直方图均衡化处理,提升后续对象检测的准确率
    cv.compareHist()
        图像直方图比较,就是计算两幅图像的直方图数据,比较两组数据的相似性,从而得到两幅图像之间的相似程度
    cv.calcBackProject()
        图像直方图反向投影是通过构建指定模板图像的二维直方图空间与目标的二维直方图空间,进行直方图数据归一化之后, 进行比率操作,对所有得到非零数值,生成查找表对原图像进行像素映射之后,再进行图像模糊输出的结果
    cv.blur()
        均值图像模糊卷积
    cv.GaussianBlur()
        高斯模糊
    均值模糊 是卷积核的系数完全一致,高斯模糊考虑了中心像素距离的影响,对距离中心像素使用高斯分布公式生成不同的权重系数给卷积核,然后用此卷积核完成图像卷积得到输出结果就是图像高斯模糊之后的输出
    cv.medianBlur()
        中值滤波对图像特定噪声类型(椒盐噪声)会取得比较好的去噪效果,也是常见的图像去噪声与增强的方法之一
    cv.fastNlMeansDenoisingColored()
        非局部均值滤波
    cv.bilateralFilter()
        高斯双边模糊,卷积处理实现图像模糊的同时对图像边缘不会造成破坏,滤波之后的输出完整的保存了图像整体边缘(轮廓)信息
    cv.pyrMeanShiftFiltering()
        均值迁移模糊,均值迁移模糊是图像边缘保留滤波算法中一种,经常用来在对图像进行分水岭分割之前去噪声,可以大幅度提升分水岭分割的效果
    cv.integral()
        图像积分图算法
    cv.edgePreservingFilter()
        快速的图像边缘滤波算法
    cv.filter2D()
        自定义卷积核来自定义的滤波器
    cv.Sobel()
        图像梯度提取算子,梯度信息是图像的最原始特征数据,进一步处理之后就可以生成一些比较高级的特征用来表示一张图像实现基于图像特征的匹配,图像分类等应用
    cv.Laplacian()
        拉普拉斯算子更容易受到噪声的扰动,所以经常对要处理的图像首先进行一个高斯模糊,然后再进行拉普拉斯算子的边缘提取,而且在一些场景中会把这两步合并成为一步,就是我们经常听说的LOG算子
    cv.convertScaleAbs()
        增强对比度
    cv.addWeighted()
        USM锐化增强算法
    cv.Canny()
        Canny编边缘检测器,有效的噪声抑制,完整边缘提取能力
    cv.pyrUp()
    cv.pyrDown()
        图像金字塔
    cv.matchTemplate()
        图像模板匹配
    cv.threshold()
        二值化
    cv.adaptiveThreshold()
        自适应阈值算法
    cv.connectedComponents()
        二值图像联通组件寻找
    cv.connectedComponentsWithStats()
        二值图像连通组件状态统计
    cv.findContours()
        获取二值图像的轮廓拓扑信息
    cv.drawContours()
        绘制轮廓
    cv.boundingRect()
    cv.minAreaRect()
        求取轮廓外接矩形
    cv.contourArea()
        轮廓点集计算面积
    cv.arcLength()
        计算轮廓曲线的弧长
    cv.approxPolyDP()
        图像二值图像的每个轮廓,可以使用轮廓逼近,逼近每个轮廓的真实几何形状,从而通过轮廓逼近的输出结果判断一个对象是什么形状
    cv.fitEllipse()
        轮廓点进行拟合,生成一个拟合的圆形或者椭圆
    cv.fitLine()
        直线拟合
    cv.dilate()
        膨胀可以看成是最大值滤波,即用最大值替换中心像素点
    cv.erode()
        腐蚀可以看出是最小值滤波,即用最小值替换中心像素点
    cv.getStructuringElement()
        获取结构元素
    cv.morphologyEx()
        形态学的操作
        开操作可以删除二值图像中小的干扰块,降低图像二值化之后噪点过多的问题
        操作可以填充二值图像中孔洞区域,形成完整的闭合区域连通组件
        顶帽操作有时候对于我们提取图像中微小部分特别有用
    cv.inpaint()
        图像修复
    cv.findHomography()
    cv.warpPerspective()
        透视变换
    cv.kmeans()
        KMeans数据分类
    cv.QRCodeDetector()
    cv.QRCodeDetector.detectAndDecode()
        二维码检测与识别

    3.PIL库接口

    Image.fromarray()
        将numpy图像转Image
    ImageFont.truetype("china.ttf", size=30)
        加载图像字体库
    ImageDraw.Draw()
        绘图
    draw.text()
        图像上添加水印

     

    展开全文
  • 将图片的像素翻转

    2019-03-14 20:00:31
    转载:... //written by Mr.zs //编程环境:VS2017 x64 /* 功能:将图片的像素翻转 zhuy */ #include &lt;opencv2\opencv.hpp&gt; #include &lt;iostream&gt; using namespace...
  • 本文主要介绍了一些简单易懂最常用的Python图像处理库。...图像处理中的常见任务包括显示图像,基本操作(如裁剪、翻转、旋转等),图像分割,分类和特征提取,图像恢复和图像识别等。 Python之成为图像处...
  • 脑PET图像分析和疾病预测挑战赛复赛经验分享1. 算法名称2. 算法描述2.1 算法思想2.1.1对数据进行裁剪处理2.1.2 数据增强2.1.3 标签平滑2.1.4 迭代交叉验证2.1.5 迁移学习2.2 流程图3 算法实现3.1 参数设置3.1.1 数据...
  • 以下提到的这些 Python 工具在编辑图像、操作...常见的图像处理操作包括显示图像,基本的图像操作,如裁剪、翻转、旋转;图像的分割、分类、特征提取;图像恢复;以及图像识别等等。Python 作为一种日益风靡的科学编...
  • 以下提到的这些 Python 工具在编辑图像、操作图像底层数据...常见的图像处理操作包括显示图像,基本的图像操作,如裁剪、翻转、旋转;图像的分割、分类、特征提取;图像恢复;以及图像识别等等。Python 作为一种日...
  • #随机水平翻转 if random . random ( ) > 0.5 : image = TF . hflip ( image ) for i in range ( mask . shape [ - 1 ] ) : mask_pil_array [ i ] = TF . hflip ( mask_pil_array [ i ] ) ...
  • 基本操作,例如裁剪,翻转,旋转等; 图像分割,分类和特征提取; 图像恢复; 和图像识别。 Python作为一种科学编程语言越来越受欢迎,并且在其生态系统中免费提供了许多最新的图像处理工具,因此Python是这...
  • pytorch 微调 图像增广

    2020-09-03 23:16:23
    图像增广有像是裁剪,随机裁剪,翻转,旋转角度,色彩,对比度变化之类种种。由于用了迁移学习,所以正确率比较高,在第一轮的训练就得到了90% 以上的正确率。
  • 十个Python图像处理工具

    千次阅读 2019-04-01 16:14:39
    这些Python库提供了一种简单直观的方法来转换图像并理解底层数据。... 基本操作如裁剪,翻转,旋转等;;图像分割,分类和特征提取;图像恢复;图像识别。Python是这些图像处理任务的绝佳选择,因为它作为一种科学...
  • Python中的十大图像处理工具

    千次阅读 2019-06-08 13:28:47
    本文主要介绍了一些简单易懂最常用的Python图像处理库 当今世界充满了各种数据...图像处理中的常见任务包括显示图像,基本操作(如裁剪、翻转、旋转等),图像分割,分类和特征提取,图像恢复和图像识别等。Python...
  • 数字图像处理课后习题汇总

    千次阅读 2020-12-22 16:17:41
    文章目录绪论Chapter 0 Course 1 WhatChapter 0 Cours 2Chapter 0 Course 3第一章Chapter 1 Introduction 1 HistoryChapter 1 Introduction 2 ...imagingChapter 2 digitization 3 step数字图像马赛克第三章Chapter 3 Color 1 M
  • 一阶导数通常在图像中产生较粗的边缘 二阶导数对精细细节,如细线、孤立点和噪声有较强的响应 二阶导数在灰度斜坡和灰度台阶过渡处会产生双边缘响应 二阶导数的符号可用于确定边缘的过渡是从亮到暗还是从暗到亮 孤立...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 745
精华内容 298
关键字:

mr图像翻转的原因