def test_plot_plugin():
    viewer = ImageViewer(data.moon())
    plugin = PlotPlugin(image_filter=lambda x: x)
    viewer += plugin

    assert_equal(viewer.image, data.moon())
    plugin._update_original_image(data.coins())
    assert_equal(viewer.image, data.coins())
    viewer.close()

def test_canny():
    image = data.camera()
    viewer = ImageViewer(image)
    c = CannyPlugin()
    viewer += c

    canny_edges = viewer.show(False)
    viewer.close()
    edges = canny_edges[0][0]
    assert edges.sum() == 2852

def show_disparity_map(disparity_map):
    #Scale to zero:
    image = np.subtract(disparity_map, np.min(disparity_map))

    if np.max(image) != 0:
        #Normalize and invert:
        image = np.multiply(image, 255.0/float(np.max(image)))

    #Show the stuff:
    viewer = ImageViewer(image.astype(np.uint8))
    viewer.show()

def test_viewer_with_overlay():
    img = data.coins()
    ov = OverlayPlugin(image_filter=sobel)
    viewer = ImageViewer(img)
    viewer += ov

    import tempfile
    _, filename = tempfile.mkstemp(suffix='.png')

    ov.color = 3
    assert_equal(ov.color, 'yellow')
    viewer.save_to_file(filename)
    ov.display_filtered_image(img)
    assert_equal(ov.overlay, img)
    ov.overlay = None
    assert_equal(ov.overlay, None)
    ov.overlay = img
    assert_equal(ov.overlay, img)
    assert_equal(ov.filtered_image, img)

def test_line_profile_dynamic():
    """Test a line profile updating after an image transform"""
    image = data.coins()[:-50, :]  # shave some off to make the line lower
    image = skimage.img_as_float(image)
    viewer = ImageViewer(image)

    lp = LineProfile(limits='dtype')
    viewer += lp

    line = lp.get_profiles()[-1][0]
    assert line.size == 129
    assert_almost_equal(np.std(viewer.image), 0.208, 3)
    assert_almost_equal(np.std(line), 0.229, 3)
    assert_almost_equal(np.max(line) - np.min(line), 0.725, 1)

    viewer.image = skimage.img_as_float(median(image,
                                               selem=disk(radius=3)))

    line = lp.get_profiles()[-1][0]
    assert_almost_equal(np.std(viewer.image), 0.198, 3)
    assert_almost_equal(np.std(line), 0.220, 3)
    assert_almost_equal(np.max(line) - np.min(line), 0.639, 1)

from skimage import data
from skimage.filters import canny

from skimage.viewer import ImageViewer
from skimage.viewer.widgets import Slider
from skimage.viewer.widgets.history import SaveButtons
from skimage.viewer.plugins.overlayplugin import OverlayPlugin


image = data.camera()

# You can create a UI for a filter just by passing a filter function...
plugin = OverlayPlugin(image_filter=canny)
# ... and adding widgets to adjust parameter values.
plugin += Slider('sigma', 0, 5)
plugin += Slider('low threshold', 0, 255)
plugin += Slider('high threshold', 0, 255)
# ... and we can also add buttons to save the overlay:
plugin += SaveButtons(name='Save overlay to:')

# Finally, attach the plugin to an image viewer.
viewer = ImageViewer(image)
viewer += plugin
canny_edges = viewer.show()[0][0]

 def show(self):
     viewer = ImageViewer(self.image)
     viewer.show()

 def viewImage(image):
     viewer = ImageViewer(image)
     viewer.show()

def testinterp(noiselevel, pointfrac):

    # Definitions
    dimx     = 100
    dimy     = 100
    dens     = 0.1
    dx2      = dimx/2
    dy2      = dimy/2
    startval = 3.0
    l   = 0.01
    maxitt   = 10

    # define ground truth
    GT = np.zeros((dimx, dimy))
    GT[0:dx2,0:dy2] = - 10.0
    GT[0:dx2,dy2+1:] = 0.0
    GT[dx2+1:,0:dy2] = 5.0
    GT[dx2+1:,dy2+1:] = 15.0

    # generate data
    Data = GT + noiselevel*np.random.randn(dimx,dimy)
    points = (np.random.rand(dimx,dimy) < pointfrac)
    values = np.multiply((1*points), Data)
    start = startval*np.ones((dimx,dimy))

    print "Interpolating..."
    Ipim = interp(start, points, values, maxitt, l)
    print "Done!"

    # compare and display result

    err1 = (Data - Ipim)
    err = np.absolute(Data - Ipim)
    errsq = err1.dot(err1)

    rms= math.sqrt(errsq.sum())/float(dimx*dimy)
    print 'average reconstruction error:', rms

    shGT = GT - GT.min()
    shGT = shGT/float(shGT.max())
    shIp = Ipim - Ipim.min()
    shIp = shIp/float(shIp.max())
    sher = err - err.min()
    sher = sher/float(sher.max())

    #h = figure(1);
    #subplot(2,2,1);

    print "ground truth"
    view = ImageViewer(shGT)
    view.show()

    print 'Reconstruction'
    view = ImageViewer(shIp)
    view.show()


    print 'Sparse point position'
    view = ImageViewer(points)
    view.show()

    print 'Reconstruction error'
    view = ImageViewer(sher)
    view.show()

def check(train_set_x, train_set_y, val_set_x, val_set_y):

    print(train_set_y[0])
    viewer = ImageViewer(train_set_x[0])
    viewer.show()

    print(train_set_y[10])
    viewer = ImageViewer(train_set_x[10])
    viewer.show()

    print(train_set_y[32])
    viewer = ImageViewer(train_set_x[32])
    viewer.show()

    print(train_set_y[56])
    viewer = ImageViewer(train_set_x[56])
    viewer.show()

    print(train_set_y[76])
    viewer = ImageViewer(train_set_x[76])
    viewer.show()

    print(train_set_y[119])
    viewer = ImageViewer(train_set_x[119])
    viewer.show()

    print(val_set_y[5])
    viewer = ImageViewer(val_set_x[5])
    viewer.show()

    print(val_set_y[13])
    viewer = ImageViewer(val_set_x[13])
    viewer.show()

    print(val_set_y[32])
    viewer = ImageViewer(val_set_x[32])
    viewer.show()

    print(val_set_y[51])
    viewer = ImageViewer(val_set_x[51])
    viewer.show()

    print(val_set_y[75])
    viewer = ImageViewer(val_set_x[75])
    viewer.show()

    print(val_set_y[145])
    viewer = ImageViewer(val_set_x[145])
    viewer.show()

def show_matching(img, img2, matching):
    print "matching..."
    ip_match = build_match_dic(img, img2, matching)

    print "Constructing intermediate image..."
    padding = 5 #padding around the edges

    bar = np.ndarray((img.shape[0], 5))
    bar.fill(1.0)
    viewer = ImageViewer(img)
    viewer.show()
    img3 = np.column_stack((img, bar, img2))
    viewer = ImageViewer(img3)
    viewer.show()

    img3 = img_as_ubyte(img3)

    viewer = ImageViewer(img3)
    viewer.show()

    img3 = np.pad(img3, pad_width=padding, mode='constant', constant_values=(0))


    viewer = ImageViewer(img3)
    viewer.show()
    print "Drawing lines..."

    colimg = color.gray2rgb(img3)
    for k,v in random.sample(ip_match.items(), int(float(len(ip_match.keys()))*0.005)):
        #Choose a random colour:
        col = [random.randint(0,255),random.randint(0,255),random.randint(0,255)]

        #Calculate coordinates after padding:
        x1 = k[0]+padding
        y1 = k[1]+padding
        x2 = v[0]+padding
        y2 = v[1] + img.shape[1]+bar.shape[1]+padding

        #Draw the points in both images:
        rr, cc = circle_perimeter(x1, y1, 3)
        colimg[rr, cc] = col
        rr, cc = circle_perimeter(x2, y2, 3)
        colimg[rr, cc] = col

        #Draw a line between the points:
        rr, cc = line(x1,y1,x2,y2)
        colimg[rr, cc] = col

    #Show the result:
    viewer = ImageViewer(colimg)
    viewer.show()

from skimage.viewer.plugins.canny import CannyPlugin


def line_image(shape, lines):
    image = np.zeros(shape, dtype=bool)
    for end_points in lines:
        end_points = np.asarray(end_points)[:, ::-1]
        image[draw.line(*np.ravel(end_points))] = 1
    return image


def hough_lines(image, *args, **kwargs):
    lines = probabilistic_hough_line(image, threshold=0.5, *args, **kwargs)
    image = line_image(image.shape, lines)
    return image


image = data.camera()
canny_viewer = ImageViewer(image)
canny_plugin = CannyPlugin()
canny_viewer += canny_plugin

hough_plugin = OverlayPlugin(image_filter=hough_lines)
hough_plugin += Slider('line length', 0, 100, value=100, update_on='move')
hough_plugin += Slider('line gap', 0, 20, value=0, update_on='move')

hough_viewer = ImageViewer(canny_plugin)
hough_viewer += hough_plugin

canny_viewer.show()

from skimage import data
from skimage.viewer import ImageViewer
from skimage.viewer.plugins.lineprofile import LineProfile


image = data.camera()
viewer = ImageViewer(image)
viewer += LineProfile()
line, profile = viewer.show()[0]

def test_viewer():
    astro = data.astronaut()
    coins = data.coins()

    view = ImageViewer(astro)
    import tempfile
    _, filename = tempfile.mkstemp(suffix='.png')

    view.show(False)
    view.close()
    view.save_to_file(filename)
    view.open_file(filename)
    assert_equal(view.image, astro)
    view.image = coins
    assert_equal(view.image, coins),
    view.save_to_file(filename),
    view.open_file(filename),
    view.reset_image(),
    assert_equal(view.image, coins)

from skimage import data
from skimage.viewer import ImageViewer
from skimage.viewer.plugins.lineprofile import LineProfile


image = data.chelsea()
viewer = ImageViewer(image)
viewer += LineProfile()
line, rgb_profiles = viewer.show()[0]

from skimage import data
from skimage.filters.rank import median
from skimage.morphology import disk

from skimage.viewer import ImageViewer
from skimage.viewer.widgets import Slider, OKCancelButtons, SaveButtons
from skimage.viewer.plugins.base import Plugin

def median_filter(image, radius):
    return median(image, selem=disk(radius))

image = data.coins()
viewer = ImageViewer(image)

plugin = Plugin(image_filter=median_filter)
plugin += Slider('radius', 2, 10, value_type='int')
plugin += SaveButtons()
plugin += OKCancelButtons()

viewer += plugin
viewer.show()

import skimage as sk
from skimage.viewer import ImageViewer

#import TomographyTools as tt
#import TomographyTools.data_management as dm
#import TomographyTools.reconstruciton as rn
import TomographyTools.image_processing as ip

inputDir = "/home/[email protected]/data-scratch/20171006_ChaiLor_PaintData/rec20171005_162920_TiO2_sample1/"

inputDirs = ['/home/[email protected]/data-scratch/20171006_ChaiLor_PaintData/rec20171005_155036_TiO2_control_scan2',
    "/home/[email protected]/data-scratch/20171006_ChaiLor_PaintData/rec20171005_162920_TiO2_sample1/",
    '/home/[email protected]/data-scratch/20171006_ChaiLor_PaintData/rec20171005_165313_TiO2_sample2',
    '/home/[email protected]/data-scratch/20171006_ChaiLor_PaintData/rec20171005_172237_TiO2_sample3']

if True:
    ip.convert_DirectoryTo8Bit(inputpath=inputDirs[0],data_min=-5.0,data_max=7.0)
    ip.convert_DirectoryTo8Bit(inputpath=inputDirs[1],data_min=-5.0,data_max=7.0)
    ip.convert_DirectoryTo8Bit(inputpath=inputDirs[2],data_min=-5.0,data_max=7.0)
    ip.convert_DirectoryTo8Bit(inputpath=inputDirs[3],data_min=-5.0,data_max=7.0)

if False:
    imageStack = ip.loadDataStack(inputDir)
    imageStack8Bit = ip.convert8bit(imageStack,-5.0,7.0)

    ip.saveTiffStack(imageStack,filename="testStack_8Bit")

    image = imageStack8Bit[:,:,50]
    viewer = ImageViewer(image); viewer.show()