def zproj(imp):
	zpimp = ZP()
	zpimp.setImage(imp)
	zpimp.setMethod(zpimp.MAX_METHOD)
	zpimp.setStartSlice(1)
	zpimp.setStopSlice(imp.getNSlices())
	zpimp.doHyperStackProjection(True)
	zpedimp = zpimp.getProjection()
	return zpedimp
Esempio n. 2
0
def projectionImage(imp):
    """Returns the MIP of the specified ImagePlus (a composite stack)"""
    from ij.plugin import ZProjector
    roi_exists = imp.getRoi() is not None
    imp.deleteRoi()
    zp = ZProjector(imp)
    zp.setMethod(ZProjector.MAX_METHOD)
    zp.setStartSlice(1)
    zp.setStopSlice(imp.getNSlices())
    zp.doHyperStackProjection(True)
    mip_imp = zp.getProjection()
    mip_imp.setCalibration(imp.getCalibration())
    if roi_exists:
        mip_imp.restoreRoi()
    return mip_imp
Esempio n. 3
0
def projectionImage(imp):
    """Returns the MIP of the specified ImagePlus (a composite stack)"""
    from ij.plugin import ZProjector
    roi_exists = imp.getRoi() is not None
    imp.deleteRoi()
    zp = ZProjector(imp)
    zp.setMethod(ZProjector.MAX_METHOD)
    zp.setStartSlice(1)
    zp.setStopSlice(imp.getNSlices())
    zp.doHyperStackProjection(True)
    mip_imp = zp.getProjection()
    mip_imp.setCalibration(imp.getCalibration())
    if roi_exists:
        mip_imp.restoreRoi()
    return mip_imp
def Zproj(stackimp, method, z_ind, z_range):
    # Gets a stack and max project it.
    #	imp= stackimp.duplicate()
    zp = ZProjector(stackimp)
    if method == "MAX":
        print "MAX"
        zp.setMethod(ZProjector.MAX_METHOD)
    elif method == "SUM":
        print "SUM"
        zp.setMethod(ZProjector.MAX_METHOD)
    print "+/-", int(z_range / 2), "of z-index", z_ind
    zp.setStartSlice(z_ind - int(z_range / 2))
    zp.setStopSlice(z_ind + int(z_range / 2))
    zp.doProjection()
    zpimp = zp.getProjection()
    return zpimp
def Zproj(stackimp,method,z_ind,z_range):
	"""
	Gets a single channel z-stack as imp and max project it using the provided method.
	stackimp(ImagePlus): a single channel z-stack as ImagePlus object
	z_index(int): The central stack number
	z_range(int): The total number of stacks surrounding the z_index to indclude
	"""
	from ij.plugin import ZProjector
#	imp= stackimp.duplicate()
	zp = ZProjector(stackimp)
	if method=="MAX":
		print "MAX"
		zp.setMethod(ZProjector.MAX_METHOD)
	elif method=="SUM":
		zp.setMethod(ZProjector.MAX_METHOD)
	zp.setStartSlice(z_ind-int(z_range/2))
	zp.setStopSlice(z_ind+int(z_range/2))
	zp.doProjection()
	zpimp = zp.getProjection()
	return zpimp
Esempio n. 6
0
def glidingprojection(imp,
                      startframe=1,
                      stopframe=None,
                      glidingFlag=True,
                      no_frames_per_integral=3,
                      projectionmethod="Median"):
    """This function subtracts the gliding projection of several frames from the
    input stack. Thus, everything which moves too fast is filtered away.

    Args:
        imp (ImagePlus): Input image as ImagePlus object.
        startframe (int, optional): Choose a start frame. Defaults to 1.
        stopframe (int, optional): Choose an end frame. Defaults to None.
        glidingFlag (bool, optional): Should a gliding frame by frame projection be used? Defaults to True.
        no_frames_per_integral (int, optional): Number of frames to project each integral. Defaults to 3.
        projectionmethod (str, optional): Choose the projection method. Options are 
        'Average Intensity', 'Max Intensity', 'Min Intensity', 'Sum Slices', 'Standard Deviation', 'Median'. Defaults to "Median".

    Raises:
        RuntimeException: Start frame > stop frame.

    Returns:
        ImagePlus: The output stack.
    """
    # Store some image properties.
    cal = imp.getCalibration()
    width, height, nChannels, nSlices, nFrames = imp.getDimensions()
    title = imp.getTitle()

    # Some simple sanity checks for input parameters.
    if stopframe == None: stopframe = nFrames
    if (startframe > stopframe):
        IJ.showMessage("Start frame > Stop frame, can't go backwards in time!")
        raise RuntimeException("Start frame > Stop frame!")

    # If a subset of the image is to be projected, these lines of code handle that.
    if ((startframe != 1) or (stopframe != nFrames)):
        imp = Duplicator().run(imp, 1, nChannels, 1, nSlices, startframe,
                               stopframe)

    # Define the number of frames to advance per step based on boolean input parameter glidingFlag.
    if glidingFlag: frames_to_advance_per_step = 1
    else: frames_to_advance_per_step = no_frames_per_integral

    # Make a dict containg method_name:const_fieled_value pairs for the projection methods
    methods_as_strings = [
        'Average Intensity', 'Max Intensity', 'Min Intensity', 'Sum Slices',
        'Standard Deviation', 'Median'
    ]
    methods_as_const = [
        ZProjector.AVG_METHOD, ZProjector.MAX_METHOD, ZProjector.MIN_METHOD,
        ZProjector.SUM_METHOD, ZProjector.SD_METHOD, ZProjector.MEDIAN_METHOD
    ]
    method_dict = dict(zip(methods_as_strings, methods_as_const))

    # Initialize a ZProjector object and an empty stack to collect projections.
    zp = ZProjector(imp)
    zp.setMethod(method_dict[projectionmethod])
    outstack = imp.createEmptyStack()

    # Loop through all the frames in the image, and project that frame with the other frames in the integral.
    for frame in range(1, nFrames + 1, frames_to_advance_per_step):
        zp.setStartSlice(frame)
        zp.setStopSlice(frame + no_frames_per_integral)
        zp.doProjection()
        outstack.addSlice(zp.getProjection().getProcessor())

    # Create an image processor from the newly created Z-projection stack
    # nFrames = outstack.getSize()/nChannels
    impout = ImagePlus(
        title + '_' + projectionmethod + '_' + str(no_frames_per_integral) +
        '_frames', outstack)
    impout = HyperStackConverter.toHyperStack(impout, nChannels, nSlices,
                                              nFrames)
    impout.setCalibration(cal)
    return impout
Esempio n. 7
0

options = getOptions()
if options is not None:
    runCamR, runCamL, CamRScale, CamLScale, BackgroundWindowStart, BackgroundWindowEnd, GridSize, TranslateR, TranslateL = options  # unpack each parameter
    print runCamR, runCamL, CamRScale, CamLScale, BackgroundWindowStart, BackgroundWindowEnd, GridSize, TranslateR, TranslateL

if runCamR:
    impR1 = FolderOpener.open(folder, "file=CamR sort")
    UID = impR1.title
    filepath = folder.strip(UID + '/')

    projectR = ZProjector(impR1)
    projectR.setMethod(ZProjector.AVG_METHOD)
    projectR.setImage(impR1)
    projectR.setStartSlice(int(BackgroundWindowStart))
    projectR.setStopSlice(int(BackgroundWindowEnd))
    projectR.doProjection()
    projectionR = projectR.getProjection()

    impR2 = ImageCalculator().run("Subtract create stack", impR1, projectionR)
    IJ.run(impR2, "Enhance Contrast", "saturated=0.4 process_all")
    IJ.run(impR2, "Set Scale...",
           "distance=" + str(CamRScale) + " known=1 unit=cm")
    IJ.run(impR2, "Grid...",
           "grid=Lines area=" + str(GridSize) + " color=Cyan")
    IJ.run(impR2, "Translate...",
           "x=" + str(TranslateR) + " y=0 interpolation=None stack")

    savepath = path.join(folder, UID + "_CR.tif")
    print savepath
Esempio n. 8
0
def ColMigBud():
    def setupDialog(imp):

        gd = GenericDialog("Collective migration buddy options")
        gd.addMessage("Collective migration buddy 2.0, you are analyzing: " +
                      imp.getTitle())
        calibration = imp.getCalibration()

        if (calibration.frameInterval > 0):
            default_interval = calibration.frameInterval
            default_timeunit = calibration.getTimeUnit()

        else:
            default_interval = 8
            default_timeunit = "min"

        gd.addNumericField("Frame interval:", default_interval,
                           2)  # show 2 decimals
        gd.addCheckbox("Do you want to use a gliding window?", True)
        gd.addCheckbox(
            "Project hyperStack? (defaluts to projecting current channel only)",
            False)
        gd.addStringField("time unit", default_timeunit, 3)
        gd.addSlider("Start compacting at frame:", 1, imp.getNFrames(), 1)
        gd.addSlider("Stop compacting at frame:", 1, imp.getNFrames(),
                     imp.getNFrames())
        gd.addNumericField("Number of frames to project in to one:", 3,
                           0)  # show 0 decimals

        gd.addChoice('Method to use for frame projection:', methods_as_strings,
                     methods_as_strings[5])

        gd.showDialog()

        if gd.wasCanceled():
            IJ.log("User canceled dialog!")
            return

        return gd

    #Start by getting the active image window and get the current active channel and other stats
    imp = WindowManager.getCurrentImage()
    cal = imp.getCalibration()
    nSlices = 1  #TODO fix this in case you want to do Z-stacks
    title = imp.getTitle()
    current_channel = imp.getChannel()
    #zp = ZProjector(imp)

    #Make a dict containg method_name:const_fieled_value pairs for the projection methods
    methods_as_strings = [
        'Average Intensity', 'Max Intensity', 'Min Intensity', 'Sum Slices',
        'Standard Deviation', 'Median'
    ]
    methods_as_const = [
        ZProjector.AVG_METHOD, ZProjector.MAX_METHOD, ZProjector.MIN_METHOD,
        ZProjector.SUM_METHOD, ZProjector.SD_METHOD, ZProjector.MEDIAN_METHOD
    ]
    medthod_dict = dict(zip(methods_as_strings, methods_as_const))

    # Run the setupDialog, read out and store the options
    gd = setupDialog(imp)
    frame_interval = gd.getNextNumber()
    time_unit = gd.getNextString()
    glidingFlag = gd.getNextBoolean()
    hyperstackFlag = gd.getNextBoolean()

    #Set the frame interval and unit, and store it in the ImagePlus calibration
    cal.frameInterval = frame_interval
    cal.setTimeUnit(time_unit)
    imp.setCalibration(cal)

    start_frame = int(gd.getNextNumber())
    stop_frame = int(gd.getNextNumber())

    #If a subset of the image is to be projected, these lines of code handle that
    if (start_frame > stop_frame):
        IJ.showMessage("Start frame > Stop frame, can't go backwards in time!")
        raise RuntimeException("Start frame > Stop frame!")

    if ((start_frame != 1) or (stop_frame != imp.getNFrames())):
        imp = Duplicator().run(imp, 1, nChannels, 1, nSlices, start_frame,
                               stop_frame)

    no_frames_per_integral = int(gd.getNextNumber())

    #the doHyperstackProjection method can't project past the end of the stack
    if hyperstackFlag:
        total_no_frames_to_project = imp.getNFrames() - no_frames_per_integral
    #the doProjection method can project past the end, it just adds black frames at the end
    #When not projecting hyperstacks, just copy the current active channel from the active image
    else:
        total_no_frames_to_project = imp.getNFrames()
        imp = Duplicator().run(imp, current_channel, current_channel, 1,
                               nSlices, start_frame, stop_frame)

    #The Z-Projection magic happens here through a ZProjector object
    zp = ZProjector(imp)
    projection_method = gd.getNextChoice()
    chosen_method = medthod_dict[projection_method]
    zp.setMethod(chosen_method)
    outstack = imp.createEmptyStack()

    if glidingFlag:
        frames_to_advance_per_step = 1
    else:
        frames_to_advance_per_step = no_frames_per_integral

    for frame in range(1, total_no_frames_to_project,
                       frames_to_advance_per_step):
        zp.setStartSlice(frame)
        zp.setStopSlice(frame + no_frames_per_integral)
        if hyperstackFlag:
            zp.doHyperStackProjection(False)
            projected_stack = zp.getProjection().getStack()
            for channel in range(projected_stack.getSize()):
                outstack.addSlice(projected_stack.getProcessor(channel + 1))
        else:
            zp.doProjection()
            outstack.addSlice(zp.getProjection().getProcessor())

    #Create an image processor from the newly created Z-projection stack
    nChannels = imp.getNChannels()
    nFrames = outstack.getSize() / nChannels
    imp2 = ImagePlus(
        title + '_' + projection_method + '_' + str(no_frames_per_integral) +
        '_frames', outstack)
    imp2 = HyperStackConverter.toHyperStack(imp2, nChannels, nSlices, nFrames)
    imp2.show()

    Startmenu()
Esempio n. 9
0
def CheckMoment(image):
	
	#Perform a maximum projection on the stack	
	stack = image.getStack()
	NSlices=image.getNSlices()
	#Take a fixed number of central slices
	i=float(NSlices-SimulationCharacteristics['CentralZSlices']) 
	i1=math.floor(i/2)
	i2=math.ceil(i/2)	
	startSlice=int(1+i1)
	stopSlice=int(NSlices-i2)
	p=bool(1)
	proj = ZProjector()
	proj.setMethod(ZProjector.MAX_METHOD)
	proj.setImage(image)
	proj.setStartSlice(startSlice)
	proj.setStopSlice(stopSlice)
	proj.doHyperStackProjection(p)
	imageMax = proj.getProjection()
	imageMax.show()
	stack = imageMax.getStack()
	n_slices= stack.getSize()
	

	#Get a Segmentation Mask List for every frame in the stack
	RoiList=[]
	RoiRatioList=[]
	for index in range(1, n_slices+1):
		ip = stack.getProcessor(index).convertToFloat()
		boundRoi=SegmentMask(ip)
		mask=boundRoi.getMask()
		PixelsMask=mask.getPixels()
		r=(-1)*float(sum(PixelsMask))/(ip.height*ip.width)
		RoiList.append(boundRoi)
		RoiRatioList.append(r)
#	print(RoiRatioList)		

	#Optimize the Roi List. No 1.0 ratios 
	AllRois1=all(item == 1.0 for  item in RoiRatioList)
	NFrames=len(RoiRatioList)
	if not AllRois1:
		for i in range(NFrames):
			if RoiRatioList[i]==1.0 or RoiList[i]==None:
				#Find the next value that is not 1.0
				NearestNot1=-1 
				prevIndex=i-1
				nextIndex=i+1
				Token=True #To run through the list alternating positions
				while prevIndex>=0 or nextIndex<NFrames:
					if prevIndex>0 and Token:
						if RoiRatioList[prevIndex]<0.9999:
							NearestNot1=prevIndex
							break
						else: 
							prevIndex-=1
							if nextIndex<NFrames:Token=False
							continue
					if nextIndex<NFrames:
					  
						if RoiRatioList[nextIndex]<0.9999:
							NearestNot1=nextIndex
							break
						else:
							nextIndex+=1
							if prevIndex>0: Token=True
							continue
				
				if NearestNot1!=-1:
					#Change RoiList and RoiRationList for the NearestNot1 element
					RoiList[i]=RoiList[NearestNot1]
					RoiRatioList[i]=RoiRatioList[NearestNot1]
				else:
					AllRois1=True
					print("No avaliable segmentation")
	
	if not AllRois1:
		RoiListMin=ModifyRoiList(RoiRatioList,RoiList)
	else:
		RoiListMin=[ None for i in range(len(RoiList))]
	

	#Find Optimum Scale for the Wavelet
	Gamma=endosomeCharacteristics['Gamma_media']
	To=endosomeCharacteristics['A_media']
	index=1 #Image 1
	ipOrig = stack.getProcessor(index).convertToFloat()	
	boundRoi=RoiListMin[0]
	MaxAmp,Ropt=AmplificationCurveMax(ipOrig,To,Gamma,boundRoi)
	print("Choosen Scale",Ropt)
		
	Moment3Array=[]
	for index in range(1,n_slices+1):
		print("time:"+str(index))
		ip = stack.getProcessor(index).convertToFloat()
		boundRoi=RoiListMin[index-1]
		Skew=GetSigmaWavelet(ip,Ropt,boundRoi)
  		Moment3Array.append(Skew)
		

	return Moment3Array	
for index in range(1, nSlices+1):
	ip = origStack.getProcessor(index)    
	
	#IJ.log(str(index) + " " + ip.toString()) # output info on current slice
	#IJ.run(imp, "Z Project...", "start=" + str(currStart) + " stop=" + str(currStop) + " projection=[Max Intensity]")

	#print "index=" + str(index) + "start=" + str(currStart) + " stop=" + str(currStop)
	
	if (currStart<1):
		currStart = 1
	if (currStop>nSlices):
		currStop = nSlices
	
	zp = ZProjector(imp)
	zp.setMethod(ZProjector.MAX_METHOD)
	zp.setStartSlice(currStart)
	zp.setStopSlice(currStop)
	#zp.doHyperStackProjection(True)
	
	zp.doProjection()
	tmpProject = zp.getProjection()
	zImageProcessor = tmpProject.getProcessor()
	
	if (tmpProject==None):
		print "\tNULL ZProject"
	else:
		newStack.addSlice(origStack.getSliceLabel(index), zImageProcessor)
		
	currStart = index - userSlices
	currStop = index + userSlices