DNA-FISH_mainwork_flow1.0

from fiji.threshold import Auto_Local_Threshold as ALT
from ij.gui import Roi
from imagescience.image import Image
from imagescience.feature import Laplacian
from process3d import Erode_, Dilate_, MinMaxMedian
from process3d import DistanceTransform3D as D3D
from Utilities import Counter3D
from ij.plugin import Thresholder, GaussianBlur3D, ZProjector, Duplicator
from ij.process import ImageProcessor


'''
Nucleus segmentation with laminCh   	&
3D ROI extraction from original image	&
Export to imagelist (implist)
'''
def CSplit_0(imp):
	imps = ChannelSplitter.split(imp)
	nucimp = imps[0]
	return nucimp
	
def Zpro(nucimp):
	zpnuc = ZProjector(nucimp)
	zpnuc.setMethod(ZProjector.MAX_METHOD)
	zpnuc.doProjection()
	zpnucimp = zpnuc.getProjection()
	return zpnucimp

def Gblur(zpnucimp):
	gbnuc = GaussianBlur()
	ip = zpnucimp.getProcessor()
	gbnuc.blurGaussian(ip, 3, 3, 0.01)

def AutoLoThre(zpnucimp):
	ALT().exec(zpnucimp, "Niblack", 30, 0, 0, True)
	
def AnaPar(zpnucimp):
	rt = ResultsTable() 
	measopt = ParticleAnalyzer.AREA + ParticleAnalyzer.SHAPE_DESCRIPTORS + ParticleAnalyzer.CENTROID + ParticleAnalyzer.RECT
	paopt = ParticleAnalyzer.EXCLUDE_EDGE_PARTICLES 
	paopt += ParticleAnalyzer.INCLUDE_HOLES
	paopt += ParticleAnalyzer.SHOW_MASKS
	paopt += ParticleAnalyzer.CLEAR_WORKSHEET
	apnuc = ParticleAnalyzer(paopt, measopt, rt, 3000, 40000000, 0.6, 1.0) 
	apnuc.setHideOutputImage(True) 
	apnuc.analyze(zpnucimp)
	maskimp = apnuc.getOutputImage()
	return maskimp, rt

def ModiCord(rt, imp):
	offset = 10
	implist = []
	for i in range(rt.getCounter()):
		bx = rt.getValue("BX", i) - offset
		by = rt.getValue("BY", i) - offset
		bw = rt.getValue("Width", i) + offset*2
		bh = rt.getValue("Height", i) + offset*2
		imp.setRoi(int(bx), int(by), int(bw), int(bh))
		#print int(bx), int(by), int(bw), int(bh)
		dp = Duplicator() 
		dpimp = dp.run(imp) 
		implist.append(dpimp)
		#dpimp.show()
	print len(implist)
	return implist

def Med3D(nucimp):
	medimp = MinMaxMedian.convolve(nucimp, MinMaxMedian.MEDIAN) 
	return medimp

def GauBlur3D(imp):
	gb3d = GaussianBlur3D() 
	sigma =2.0
	gb3d.blur(imp, sigma, sigma, sigma) 

def autoThre(lapimp):
	midslice = int(lapimp.getStackSize() / 2)
	lapimp.setSlice(midslice)
	ip = lapimp.getStack().getProcessor(midslice)
	ip.setAutoThreshold(AutoThresholder.Method.Default, False) 
	IJ.setThreshold(lapimp, ip.getMinThreshold(), ip.getMaxThreshold())
	IJ.run(lapimp, "Convert to Mask", "method=Default background=Light black")
	return lapimp

''''
DAPI binaryse from 3D cropped.img of DAPI channel
'''
def CSplit_2(imp):
	imps = ChannelSplitter.split(imp)
	nucimp = imps[2]
	return nucimp
	
def Erode3D(lapimp):
	er = Erode_()
	ip = lapimp.getProcessor()
	erimp = er.erode(lapimp, 255, True)
	return erimp

def Dilate(erimp):
	dil = Dilate_()
	dilimp = dil.dilate(erimp, 255, True)
	return dilimp

def obCount3d(dilimp):
	ctnuc = Counter3D(dilimp, 128, 5000, 5000000, False, False)
	ctnucob3d = ctnuc.getObject(0)
	surfimp = ctnuc.getObjMap()
	return surfimp

def multi255(imp):
	dstk = imp.getStack()
	for i in range(dstk.getSize()):
		ip = dstk.getProcessor(i +1)
		ip.multiply(255.0)

def DAPI_function(imp):
	nucimp =CSplit_2(imp)
	GauBlur3D(nucimp)
	medimp = Med3D(nucimp)
	autoThre(medimp)
	erimp = Erode3D(medimp)
	IJ.run(erimp, "Invert", "stack")
	surfimp = obCount3d(erimp)
	surfimp.show()
	multi255(surfimp)
	IJ.run(surfimp, "Fill Holes", "stack")
	IJ.run(surfimp, "Watershed", "stack")
	
	#return mulimp

''''
FISH 3D spots functions
'''
def CSplit_3(imp):
	imps = ChannelSplitter.split(imp)
	nucimp = imps[3]
	return nucimp
	
def maxZprojection(stackimp):
    zp = ZProjector(stackimp)
    zp.setMethod(ZProjector.MAX_METHOD)
    zp.doProjection()
    zpimp = zp.getProjection() 
    return zpimp

def autoThreshold_3Dspots(imp):
	zpimp = maxZprojection(imp)
	ip = zpimp.getProcessor()
	ip.setAutoThreshold(AutoThresholder.Method.Yen, False) 
	IJ.setThreshold(imp, ip.getMinThreshold(), ip.getMaxThreshold())
	#for i in range(imp.getStackSize()):
	#	lutmode = ImageProcessor.NO_LUT_UPDATE 
	#	imp.getStack().getProcessor(i+1).setThreshold(ip.getMinThreshold(), ip.getMaxThreshold(), lutmode)
	IJ.run(imp, "Convert to Mask", "method=Default background=Light black")
	return imp

def obCount3d_FISH(dilimp):
	ctnuc = Counter3D(dilimp, 200, 10, 5000000, True, False)
	ctnucob3d = ctnuc.getObject(0)
	surfimp = ctnuc.getObjMap()
	#ctnuc.showStatistics(True)
	IJ.setThreshold(surfimp, 1.0, 255.0)
	IJ.run(surfimp, "Convert to Mask", "method=Default background=Light black")
	return surfimp

def FISH_spots_function(imp):
	nucimp =CSplit_3(imp)
	medimp = Med3D(nucimp)
	autoThreshold_3Dspots(medimp)
	IJ.run(medimp, "Invert", "stack")
	cimp = obCount3d_FISH(medimp)
	cimp.show()

'''
Chr_paint function
'''
def CSplit_1(imp):
	imps = ChannelSplitter.split(imp)
	nucimp = imps[1]
	return nucimp
	
def autoThreshold_3DChr(imp):
	zpimp = maxZprojection(imp)
	ip = zpimp.getProcessor()
	ip.setAutoThreshold(AutoThresholder.Method.Yen, False) 
	IJ.setThreshold(imp, ip.getMinThreshold(), ip.getMaxThreshold())
	#for i in range(imp.getStackSize()):
	#	lutmode = ImageProcessor.NO_LUT_UPDATE 
	#	imp.getStack().getProcessor(i+1).setThreshold(ip.getMinThreshold(), ip.getMaxThreshold(), lutmode)
	IJ.run(imp, "Convert to Mask", "method=Default background=Light black")
	return imp

def obCount3d_Chr(dilimp, minSize):
	ctnuc = Counter3D(dilimp, 200, minSize, 5000000, True, False)
	ctnucob3d = ctnuc.getObject(0)
	surfimp = ctnuc.getObjMap()
	#ctnuc.showStatistics(True)
	IJ.setThreshold(surfimp, 1.0, 255.0)
	IJ.run(surfimp, "Convert to Mask", "method=Default background=Light black")
	return surfimp

def Chr_function(imp):
	nucimp =CSplit_1(imp)
	#nucimp.show()
	medimp = Med3D(nucimp)
	#medimp.show()
	autoThreshold_3DChr(medimp)
	IJ.run(medimp, "Invert", "stack")
	cimp = obCount3d_Chr(medimp, 1000) #set value
	cimp.show()

'''
Lamin function
'''
def CSplit_0(imp):
	imps = ChannelSplitter.split(imp)
	nucimp = imps[0]
	return nucimp

def LGauBlur3D(imp, sigma):
	gb3d = GaussianBlur3D() 
	gb3d.blur(imp, sigma, sigma, sigma) 
	

def FJ_Lap(medimp, val):
	img = Image.wrap(medimp)
	lap =Laplacian()
	lapimg = lap.run(img, val)
	lapimp = lapimg.imageplus()
	return lapimp

def autoThre_Lamin(lapimp):
	midslice = int(lapimp.getStackSize() / 2)
	lapimp.setSlice(midslice)
	ip = lapimp.getStack().getProcessor(midslice)
	#ip.setAutoThreshold(AutoThresholder.Method.Default, False) 
	ip.setAutoThreshold(AutoThresholder.Method.Triangle, False) 
	#ip.setAutoThreshold(AutoThresholder.Method.Mean, False) 	
	IJ.setThreshold(lapimp, ip.getMinThreshold(), ip.getMaxThreshold())
	IJ.run(lapimp, "Convert to Mask", "method=Default background=Light black")
	return lapimp

def obCount3d_Lamin(dilimp, minSize):
	ctnuc = Counter3D(dilimp, 128, minSize, 500000000, True, False)
	ctnucob3d = ctnuc.getObject(0)
	obimp = ctnuc.getObjMap()
	#ctnuc.showStatistics(True)
	IJ.setThreshold(obimp, 1.0, 255.0)
	IJ.run(obimp, "Convert to Mask", "method=Default background=Light black")
	return obimp

def Lamin_function(imp):
	nucimp =CSplit_0(imp)
	#nucimp.show()
	LGauBlur3D(nucimp, 1.5)	#set value
	medimp = Med3D(nucimp)
	#medimp.show()
	lapimp = FJ_Lap(medimp, 0.1) #set value
	#lapimp.show()
	autoThre_Lamin(lapimp)
	erimp = Erode3D(lapimp)
	#erimp.show()
	dilimp = Dilate(erimp)
	#dilimp.show()
	obimp = obCount3d_Lamin(dilimp, 5000) #set value
	obimp.show()


'''
main
'''

def mainworkflow(imp):
	nucimp = CSplit_0(imp)
	zpnucimp=Zpro(nucimp) 
	Gblur(zpnucimp)
	AutoLoThre(zpnucimp)
	maskimp, rt = AnaPar(zpnucimp)
	#rt.show("test")
	implist = ModiCord(rt, imp)
	for aimp in implist:
		DAPI_function(aimp)
		FISH_spots_function(aimp)
		Lamin_function(aimp)
		Chr_function(aimp)
		#aimp.show()
		
		# lamin - fish calculation
		#output
	
'''
Start
'''
imp = IJ.openImage("/Users/miyanari/Desktop/EMBL_with Kota/FISH_data/DNA-FISH_Demo.tif")
ROI = mainworkflow(imp)