def processIntensityFile(npix, i_file):
# #proc_id="["+multiprocessing.current_process().name+"] "
try:
# Read from file
(data2D, time,
index) = optoFluidsIO.readFromFile_Intensity1D(i_file, npix)
except Exception as error:
print("Skipping file \"" + str(i_file) + "\":\n" + str(error))
pass
else: # no exception occured, so:
# Output to file
optoFluidsIO.writeToFile_Intensity2D(data2D,
outputDN,
time,
index=index,
overwrite=overwrite)
#
###########################
# Algorithm:
##########
def computeContrastByLocalContrast(img):
SCfunc = SC.grid(
gridSize
) # Use grid-method with default settings to compute the speckle contrast.
return SCfunc(img)
## Read pixel coordinates
print("Loading pixelCoords2D from ", pixelCoordsFN)
(A, B) = optoFluidsIO.readFromFile_CoordsAB(pixelCoordsFN)
npix = np.shape(A) # first index = a direction, second index = b direction
## Read intensity file
(image, *irrelevant) = optoFluidsIO.readFromFile_Intensity(intensity2DFN, npix)
if (image.ndim != 2):
sys.exit("Intensityfile \"" + str(intensity2DFN) +
"\" does not contain 2D data. Cannot plot.")
## Plot figure:
print("Plotting figure " + str(intensity2DFN))
plt.rc('text', usetex=False) # TeXify axis/labels/title
dpi = 160
if not noAxis:
fig = plt.figure(dpi=dpi)
else:
shutil.rmtree(outputDN)
os.makedirs(outputDN)
print("Output directory '" + outputDN + "' was created.")
else: # OutputDir = InputDir
# Restructure input directory to prepare for the ouput
restructureInputDir(inputDN)
intInputDN = names.joinPaths(inputDN, names.input1DDN)
pixelCoordsFN = names.joinPaths(intInputDN, names.pixelCoordsFN)
outputDN = names.joinPaths(inputDN, names.input2DDN)
########
## Restructure PixelCoordinates
####
# Read
data3D = optoFluidsIO.readFromFile_CoordsXYZ(pixelCoordsFN)
print("data3D original = ", data3D)
shiftOrigin(data3D)
print("data3D or.shift = ", data3D)
# Convert to 2D
span = spanVectors(data3D)
data2D = projectData(data3D, span)
print("data2D = ", data2D)
#print("data2D[2][:] = ", data2D[2][:])
bound01(data2D, eps(data2D) * 0.999)
print("data2D bounded = ", data2D)
npix = getCamSize(data2D)
print("npix = ", npix)
# Write
optoFluidsIO.writeToFile_Coords2D(data2D,
outputDN,
signal_toffset = 0
signal_T = 1.0
signal_maxs = [0.25]
signal_mins = [0.75]
else: # else no vertical lines
signal_toffset = 0
signal_T = 1.0
signal_maxs = []
signal_mins = []
########
## IO ##
########
(data, header) = optoFluidsIO.readCSVs(inFNs,
delimiter=delim,
skip_header=skip_header)
# first index = row (~time)
# second index = column (~dataset)
# third index = different file (~file) --> Use [0] if only a single file.
###############
## Computing ##
###############
def is_in_range(num, rng):
return (num <= rng[1]) and (num >= rng[0])
def add_xvline(t_range):
default=False,
help="verbose? [default: %default]")
parser.add_option("-f",
action="store_true",
dest="overwrite",
default=False,
help="overwrite? [default: %default]")
(opt, args) = parser.parse_args()
myPrint.Printer.verbose = opt.verbose
# Sanity
assert (opt.inFN != None), "Please specify the input filename with -i."
assert (opt.outFN != None), "Please specify the output filename with -o."
# Input
(data, header) = optoFluidsIO.readCSV(opt.inFN, delimiter=opt.delimiter)
# Compute time->freq
t = data[:, opt.colx]
f = fftfreq(t, half=not opt.whole)
header[opt.colx] = "f"
# Compute data->fft
if opt.coly is None: # If coly is missing, then use all columns
y = data
Y = fft(y, half=not opt.whole, zeroMean=opt.zeroMean)
else: # only compute for coly
y = data[:, opt.coly]
Y = fft_dim2(y,
half=not opt.whole,
zeroMean=opt.zeroMean,
skip_col=opt.colx)
action="store_true",
dest="verbose",
default=False,
help="verbose [default: %default]")
(opt, args) = parser.parse_args()
myPrint.Printer.verbose = opt.verbose
# Pre-parse arguments
(SC_args, SC_kwargs) = RTS.multiArgStringToArgs(opt.SC_args)
# Detect whether input is an intensity file or a directory:
if myRE.doesItemMatch(os.path.basename(opt.inFDN),
myRE.compile(names.intensityFNRE)):
# Then input is an intensity filename
# Read input:
(data, time, index) = optoFluidsIO.readFromFile_Intensity(opt.inFDN)
# Compute and output:
print(computeSpeckleContrast(data, opt.SC_func, *SC_args, **SC_kwargs))
else:
# Else input is not an intensity filename. Check whether it is a result directory.
# Get multiple result directories (if any):
resultDNs = optoFluidsIO.getResultDirs(opt.inFDN)
# Compute:
SCarray = []
for resDN in resultDNs:
# TODO: How to select the appropriate intensity file? CLI?
try: # Prioritize blurred:
argument = resDN + '/2D/blurred/Intensity2D_t0.0'
(data, time,
index) = optoFluidsIO.readFromFile_Intensity(argument)
except: # No blurred, so unsorted:
os.makedirs(outputDN)
print("Output directory '" + outputDN + "' was created.")
#
###########################
# Algorithm:
##########
####
# Read the input file: PixelCoords
##
#floatRE=r"[-+]?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?"
#dataRegex = "(?m)^\s*("+floatRE+")\s+("+floatRE+")\s*$" # Matches exactly two floats
#dataRegex2 = re.compile(dataRegex)
# Read coordinate header for re-writing.
(npix, span) = optoFluidsIO.readFromFile_CoordsAB_header(pixelCoordsFN)
#coordsFile = open(pixelCoordsFN)
#coordsFile_row1 = coordsFile.readline() # skip "a=" line
#coordsFile_row2 = coordsFile.readline() # skip "b=" line
#coordsFile_row3 = coordsFile.readline() # This is the line we want: "Na Nb"
#coordsFile.close()
#dataRegex = "^\s*([0-9]+)\s+([0-9]+)\s*$" # Matches exactly two ints, space separated
#dataRegex2 = re.compile(dataRegex)
#r = dataRegex2.search(coordsFile_row3)
#if r: # If filename matches the regex
# Na = int(r.group(1))
# Nb = int(r.group(2))
#dataCoords = np.loadtxt(pixelCoordsFN, skiprows=3)
#dataCoords2D_a = np.reshape(dataCoords[:,0],(Nb,Na))
#dataCoords2D_a = np.transpose(dataCoords2D_a)
#dataCoords2D_b = np.reshape(dataCoords[:,1],(Nb,Na))