from startup import *
from ijutils import *
from ch.psi.pshell.imaging.Overlays import *
import ch.psi.pshell.imaging.Pen as Pen
import java.awt.Color as Color
import random


def get_centroid(source):
    bi = source.getImage()    
    if bi is None:
        return None
    op = show_panel(bi, "Original")
    ip = load_image(bi)  
    plot(get_histogram(ip), title = "Histogram")  
    grayscale(ip)    
    invert(ip)
    gaussian_blur(ip)    
    auto_threshold(ip)
    
    #binary_erode(ip)        
    show_panel(ip.getBufferedImage(), "Image")
    (results,output_img)=analyse_particles(ip, 2000,20000, exclude_edges=False, print_table=True)    
    op.clearOverlays()
    show_panel(output_img.getBufferedImage(), "Outlines")
    if results.size()>0:        
        centroid  = (results.getValue("XM",0), results.getValue("YM",0))
        ov = Crosshairs(Pen(Color.ORANGE),  java.awt.Point(int(centroid[0]),int(centroid[1])), java.awt.Dimension(15,15))
        op.addOverlay(ov)
        return centroid    
              



import ch.psi.pshell.imaging.Filter as Filter

class SimulatedSource(Filter):
    def process(self, img, data):      
        self.img=img  
        if img is None: 
            return None 
        ip = load_image(img)         
        pad_h = int((random.random()-0.5) * 500)
        pad_v = int((random.random()-0.5) * 500)
        #print "Pad = " , (pad_h, pad_v)
        ip = pad_image(ip, -pad_h, pad_h, pad_v, -pad_v, fill_color = Color.BLACK)
        return ip.getBufferedImage() 
        #return img
        
    def waitNext(self, timeout):
        self.pushImage(self.process(self.img, None))
        
        
       
class ImageStats(DeviceBase):
    def __init__(self, name, source):
        DeviceBase.__init__(self, name)
        self.source = source
        self.com_x_samples, self.com_y_samples = [], []
        class ComX(Readable):
            def read(self):     
                if len(self.image_stats.com_x_samples)==0: return None
                return mean(self.image_stats.com_x_samples)
        self.com_x_mean = ComX(); self.com_x_mean.image_stats = self
        class ComY(Readable):
            def read(self):     
                if len(self.image_stats.com_y_samples)==0: return None
                return mean(self.image_stats.com_y_samples)
        self.com_y_mean = ComY(); self.com_y_mean.image_stats = self
        class ComXVar(Readable):
            def read(self):     
                if len(self.image_stats.com_x_samples)==0: return None
                return stdev(self.image_stats.com_x_samples)
        self.com_x_stdev = ComXVar(); self.com_x_stdev.image_stats = self
        class ComXVar(Readable):
            def read(self):     
                if len(self.image_stats.com_y_samples)==0: return None
                return stdev(self.image_stats.com_y_samples)
        self.com_y_stdev = ComXVar(); self.com_y_stdev.image_stats = self
        set_device_alias(self.com_x_mean, name + " com x mean")
        set_device_alias(self.com_y_mean, name + " com y mean")
        set_device_alias(self.com_x_stdev, name + " com x stdev")
        set_device_alias(self.com_y_stdev, name + " com y stdev")
        self.bg_en = False
        self.num_images = 1
        self.initialize()        
    
    
    def doUpdate(self):        
        self.com_x_samples, self.com_y_samples = [], []
        for i in range(self.num_images):
            if type(self.source) is not  ch.psi.pshell.imaging.FileSource:                                
                self.source.waitNext(3000)                
            centroid = get_centroid(self.source)            
            print "cent ", centroid            
            if centroid is not None:
                self.com_x_samples.append(centroid[0])
                self.com_y_samples.append(centroid[1])

    def setNumberOfImages(self, value):
        self.num_images = value

    def enableBackground(self, value):
        self.bg_en = value
        
    def captureBackground(self, images):               
        self.doInitialize()
    
    def doClose(self):        
        pass    

    def start(self):
        pass

    def stop(self):
        pass
        

def get_simulated_source(img):
    simulated_source = SimulatedSource()           
    simulated_source.img=None
    simulated_source.initialize()
    img.addListener(simulated_source)
    show_panel(simulated_source)
    return simulated_source

if __name__ == "__builtin__":
    simulated_source = get_simulated_source(image)           
    print get_centroid(simulated_source)        
    
    add_device(ImageStats("image_stats", simulated_source), True)
    image_stats.enableBackground(False)    
    for i in range (10):        
        image_stats.update()        
        print image_stats.take(), image_stats.com_x_mean.read(), image_stats.com_y_mean.read() 
        time.sleep(1)