# @File(label = "Input directory", style = "directory") srcFile
# @String(label = "File extension", value=".tif") ext
# @Integer(label = "Number of width measurements", value="7", stepSize="1") numberOfWidthMeasurements
# Compare with the original Process_Folder to see how ImageJ 1.x
# GenericDialog use can be converted to @Parameters.

import os
from ij import IJ, ImagePlus
import fiji.analyze.directionality.Directionality_
from ij import WindowManager
import math
from ij.measure import ResultsTable
from array import zeros
from ij.plugin.frame import RoiManager

def run():
  global srcFile, ext, numberOfWidthMeasurements
  IJ.run("Set Measurements...", "area mean standard modal min centroid center perimeter bounding fit shape feret's integrated median skewness kurtosis area_fraction display redirect=None decimal=3");
  IJ.setForegroundColor(255,255,255);
  IJ.setBackgroundColor(0,0,0);  
  IJ.run("Options...", "iterations=1 count=1 black");
  table = ResultsTable()
  srcDir = srcFile.getAbsolutePath()
  for root, directories, filenames in os.walk(srcDir):
    for filename in filenames:
      # Check for file extension
      if not filename.endswith(ext):
        continue
      # Check for file name pattern
      process(srcDir, root, filename, table, numberOfWidthMeasurements)
  table.save(os.path.join(srcDir, 'Results.xls'))
  
def process(srcDir, currentDir, fileName, table, numberOfWidthMeasurements):
    if "control-images" in currentDir:
      return   
    print "Processing:"
    # Opening the image
    print "Open image file", fileName
    imp = IJ.openImage(os.path.join(currentDir, fileName)) 
    # Put your processing commands here!
    imp.show()
   
    processCurrentImage(table);

    impIn = WindowManager.getCurrentImage()
    path = os.path.join(srcDir, 'control-images')
    if not os.path.exists(path):
      os.makedirs(path)
    IJ.save(os.path.join(path, fileName))
    impIn.changes = False
    impIn.close()

def processCurrentImage(table):
    imp = WindowManager.getCurrentImage()
    fileName = imp.getTitle()
    middleSlice = int(math.floor(imp.getNFrames() / 2.0) + (imp.getNFrames() % 2))
    imp.setSlice(middleSlice)
    IJ.run("Duplicate...", " ")
    imp.close()
    imp = WindowManager.getCurrentImage()
    
    dir = fiji.analyze.directionality.Directionality_()
    dir.setImagePlus(imp)
    dir.setMethod(fiji.analyze.directionality.Directionality_.AnalysisMethod.FOURIER_COMPONENTS)
    dir.setBinNumber(90)
    dir.setBinStart(-90)
    dir.setBuildOrientationMapFlag(False)
        
    dir.computeHistograms()
    dir.fitHistograms()
    results = dir.getFitAnalysis()
    direction = math.degrees(results[0][0])
    dispersion = math.degrees(results[0 ][1])
    amount = results[0][2]
    goodness = results[0][3]
    IJ.run("Clear Results")
    IJ.run("FFT")
    fftImp = WindowManager.getCurrentImage()
    
    IJ.run("Mean...", "radius=2");
    IJ.run("Find Maxima...", "noise=15 output=[Point Selection]")
    IJ.run("Measure")
    fftImp.changes = False
    fftImp.close()
      
    rt = ResultsTable.getResultsTable()
    size = rt.size()
    numberOfFrequences = size
    if size>=5: 
       numberOfFrequences = 5
    R = zeros('f', numberOfFrequences)
    Theta = zeros('f', numberOfFrequences)
    for i in range(0, numberOfFrequences):
       R[i] = rt.getValue("R", i)
       Theta[i] = rt.getValue("Theta", i)
    table.incrementCounter()
    table.addValue('image', fileName)
    table.addValue('Direction', direction)
    table.addValue('Dispersion', dispersion)
    table.addValue('Amount', amount)
    table.addValue('Goodness', goodness)
    for i in range(0, numberOfFrequences):
       table.addValue('R'+str(i), R[i])
       table.addValue('Theta'+str(i), Theta[i])
    
    widths = measureWidth(numberOfWidthMeasurements)
    i = 1;
    for width in widths:
      table.addValue("width" + str(i), width)        
      i = i + 1
    headings = rt.getHeadings()
    for heading in headings:
      if heading != "Label":
        value = rt.getValue(heading, 0)
        table.addValue(heading, value)
    table.show('Directonality analysis')
    
def measureWidth(numberOfWidthMeasurements):
  impIn = WindowManager.getCurrentImage()
  title = impIn.getTitle()
  IJ.run("Duplicate...", " ")
  impWork =  WindowManager.getCurrentImage()
  workTitle = impWork.getTitle()
  IJ.run("Clear Results")
  IJ.run("Measure")
  rt = ResultsTable.getResultsTable()
  min = rt.getValue("Min", 0)  
  IJ.run("Subtract...", "value=" + str(min))
  IJ.resetMinAndMax()
  imp = WindowManager.getCurrentImage()
  width = imp.getWidth()
  height = imp.getHeight()
  IJ.setAutoThreshold(imp, "Mean dark")
  roiManager = RoiManager.getRoiManager()
  roiManager.reset()
  IJ.run("Analyze Particles...", "size=1000-Infinity add")
  IJ.run("Clear Results")
  roiManager.select(0)
  roiManager.runCommand("Measure")
  angle = rt.getValue("Angle", 0)
  IJ.run("Select None")
  roiManager.runCommand("Delete")
  IJ.run("Rotate... ", "angle="+str(angle)+" grid=1 interpolation=Bilinear enlarge")
  IJ.setAutoThreshold(imp, "Li dark")
  IJ.run("Convert to Mask")
  IJ.run("Fill Holes")
  roiManager.reset()
  IJ.run("Analyze Particles...", "size=1000-Infinity add")
  IJ.run("Clear Results")
  roiManager.select(0)
  IJ.run("Clear Outside")
  IJ.selectWindow(title)
  IJ.run("Rotate... ", "angle="+str(angle)+" grid=1 interpolation=Bilinear enlarge")
  roiManager.select(0) 
  roiManager.runCommand("Measure")
  IJ.run("Select None")
  IJ.run("Rotate... ", "angle="+str(-angle)+" grid=1 interpolation=Bilinear enlarge")
  IJ.run("Canvas Size...", "width="+str(width)+" height="+str(height)+" position=Center zero")
  IJ.selectWindow(workTitle)
  xBox = rt.getValue("BX", 0)
  lengthBox = rt.getValue("Width", 0)
  heightBox = rt.getValue("Height", 0)
  lengthEllipse = rt.getValue("Major", 0)
  heightEllipse = rt.getValue("Minor", 0)
  calibration = imp.getCalibration()
  xMiddle = int(round(((lengthBox - xBox) / 2.0) + xBox, 0))
  xOuter = xBox + lengthBox
  xInner = xBox
  widths = zeros('f', numberOfWidthMeasurements)
  delta = (xOuter - xInner) / (numberOfWidthMeasurements + 1.0)
  for i in range(1,numberOfWidthMeasurements+1):
    deltaLen = delta * i;
    xM = xInner + deltaLen
    widths[i-1] = getWidthAt(xM, imp)
  IJ.run("Flatten");
  IJ.run("Rotate... ", "angle="+str(-angle)+" grid=1 interpolation=Bilinear enlarge")
  IJ.run("Canvas Size...", "width="+str(width)+" height="+str(height)+" position=Center zero")
  impFlat = WindowManager.getCurrentImage()
  imp.changes = False;
  imp.close()
  titleIn = impIn.getTitle()
  titleFlat = impFlat.getTitle()
  IJ.selectWindow(titleIn)
  IJ.run("Add Image...", "image=" + titleFlat + " x=0 y=0 opacity=50 zero")
  impFlat.changes = False
  impFlat.close()
  return widths
  
def getWidthAt(x, imp):
  ip = imp.getProcessor()
  calibration = imp.getCalibration()
  height = ip.getHeight()
  lastValue = 0
  numberOfTimesValueChanged = 0;
  startY = 0;
  endY = 0
  xUnscaled = int(round(calibration.getRawX(x),0))
  for i in range(0, height-1):
    newValue = ip.get(xUnscaled, i)
    if lastValue!=newValue:
        if numberOfTimesValueChanged==0: 
          startY = i
          numberOfTimesValueChanged = numberOfTimesValueChanged + 1
        endY = i
    lastValue = newValue;
  calibration = imp.getCalibration()
  yS = calibration.getY(startY)
  yE = calibration.getY(endY)
  IJ.makeLine(xUnscaled, startY, xUnscaled, endY)
  IJ.run("Add Selection...")
  return yE-yS

if 'getArgument' in globals():
  parameter = getArgument()
  args = parameter.split(",")
  arg1 = args[0]
  arg2 = args[1]
  arg3 = args[2]
  val1 = arg1.split("=")
  val2 = arg2.split("=")
  val3 = arg3.split("=")
  srcFile = val1[1]
  ext = val2[1]
  numberOfWidthMeasurements = int(val3[1])
  
  if srcFile=="None":
    table = ResultsTable()
    processCurrentImage(table)
  else:
    srcFile = File(val1[1])
    run()