def synapsin_concentrations():
""" Synapsin concentration comparisons """
resolution = {'res_xy_nm': 100, 'res_z_nm': 70}
thresh = 0.9
base_dir = '/Users/anish/Documents/Connectome/Synaptome-Duke/data/antibodyanalysis/Dilutions/KDM-SYN-110228/'
folder_names = ['Stacks SynCS 100', 'Stacks SynCS 1000']
target_antibody_name = 'ASynCS_1st.tif'
conjugate_antibody_name = 'AVGluT1_3rd.tif'
conjugate_filenames = []
target_filenames = []
query_list = []
for fn in folder_names:
query = {
'preIF': [target_antibody_name, conjugate_antibody_name],
'preIF_z': [2, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
target_filenames.append(target_antibody_name)
conjugate_filenames.append(conjugate_antibody_name)
measure_list = aa.calculate_measure_lists(query_list, folder_names,
base_dir, thresh, resolution,
target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames,
conjugate_filenames)
print(df)
return df
def glur3_concentrations():
"""GLUR3 concentration comparisons """
resolution = {'res_xy_nm': 100, 'res_z_nm': 70}
thresh = 0.9
base_dir = '/Users/anish/Documents/Connectome/Synaptome-Duke/data/antibodyanalysis/Dilutions/KDM-SYN-120322/'
folder_names = ['GluR3_25', 'GluR3_125', 'GluR3_625', 'GluR3_3125']
target_antibody_name = 'GluR3_1stA.tif'
conjugate_antibody_name = 'VGluT1A.tif'
conjugate_filenames = []
target_filenames = []
query_list = []
for fn in folder_names:
query = {
'preIF': [conjugate_antibody_name],
'preIF_z': [2],
'postIF': [target_antibody_name],
'postIF_z': [2],
'punctumSize': 2
}
query_list.append(query)
target_filenames.append(target_antibody_name)
conjugate_filenames.append(conjugate_antibody_name)
measure_list = aa.calculate_measure_lists(query_list, folder_names,
base_dir, thresh, resolution,
target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames,
conjugate_filenames)
print(df)
return df
def gephyrin_multipleclones():
"""Gephyrin multiple clone comparisons
"""
folder_names = ['3-2-1', '4-2', '22-3', '23-1', '73-2', '83-1', '93-1']
base_dir = '/Users/anish/Documents/Connectome/Synaptome-Duke/data/antibodyanalysis/L106-Gephyrin/'
resolution = {'res_xy_nm': 100, 'res_z_nm': 70}
thresh = 0.9
target_filenames = ['3-2-1-cloneA.tif', '4-2-cloneA.tif', '22-3-cloneA.tif',
'23-1-cloneA.tif', '73-2-cloneA.tif', '83-1-cloneA.tif',
'93-1-cloneA.tif']
conjugate_filenames = ['3-2-1-GADA.tif', '4-2-GADA.tif', '22-3-GADA.tif',
'23-1-GADA.tif', '73-2-GADA.tif', '83-1GADA.tif',
'93-1-GADA.tif']
query_list = []
for n in range(0, len(target_filenames)):
target_name = target_filenames[n]
conjugate_name = conjugate_filenames[n]
query = {'preIF': [conjugate_name], 'preIF_z': [2],
'postIF': [target_name], 'postIF_z': [2],
'punctumSize': 2}
query_list.append(query)
measure_list = aa.calculate_measure_lists(query_list, folder_names, base_dir,
thresh, resolution, target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames, conjugate_filenames)
print(df)
return df
def VGAT_lowicryl_multipleclones():
""" VGAT_lowicryl_multipleclones
"""
base_dir = '/Users/anish/Documents/Connectome/Synaptome-Duke/data/antibodyanalysis/L118-VGAT/Lowicryl/'
folder_names = aa.getListOfFolders(base_dir)
resolution = {'res_xy_nm': 100, 'res_z_nm': 70}
thresh = 0.9
conjugate_filename_str = 'GAD'
target_filename_str = 'VGAT'
conjugate_filenames = []
target_filenames = []
query_list = []
for foldername in folder_names:
target_name = aa.find_filename(target_filename_str, foldername, base_dir)
conjugate_name = aa.find_filename(conjugate_filename_str, foldername, base_dir)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {'preIF': [target_name, conjugate_name], 'preIF_z': [2, 2],
'postIF': [], 'postIF_z': [],
'punctumSize': 2}
query_list.append(query)
measure_list = aa.calculate_measure_lists(query_list, folder_names, base_dir,
thresh, resolution, target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames, conjugate_filenames)
print(df)
return df
def psd_pairwise_comparison():
"""Compare two PSD-95 clones. This is just one way of setting up the
queries/data locations. See the 'antibody_analysis' folder for multiple examples
of how to set up the tool.
Query Format (dict):
preIF : list of strs - name of the channel
preIF_z : list of ints - number of slices to span. default=[2]
postIF : list of strs
postIF_z : list of ints. default=[2]
punctumSize : number of pixels x/y that a puncta should span. default=2
Returns
-----------------
df : dataframe - contains the results of the SACT
"""
# Location of the data
base_dir = '../example/'
# Data resolution, in nanometers
resolution = {'res_xy_nm': 100, 'res_z_nm': 70}
# Threshold value for the probability maps. This value does not usually need to be changed.
thresh = 0.9
# List the file names
target_filenames = ['PSD95m_1st.tif', 'PSD95r_2nd.tif']
reference_filenames = ['synapsin_1st.tif', 'synapsin_1st.tif']
# Create a query for each pair
query_list = []
for n in range(0, len(target_filenames)):
target_name = target_filenames[
n] # The AB we're interested in testing (PSD)
reference_name = reference_filenames[
n] # The previously validated AB (synapsin)
# Formulate the query
query = {
'preIF': [reference_name],
'preIF_z': [2],
'postIF': [target_name],
'postIF_z': [2],
'punctumSize': 2
}
query_list.append(query)
# Run the SACT
measure_list = aa.calculate_measure_lists(query_list, None, base_dir,
thresh, resolution,
target_filenames)
# Convert measure object to a dataframe
project_names = ['PSD_M', 'PSD_R']
df = aa.create_df(measure_list, project_names, target_filenames,
reference_filenames)
print(df)
return df
def mitochrondia_170906():
""" Run antibody characterization tool on the L113-Homer dataset
Return
----------
df : dataframe - contains results
"""
# Location of data
base_dir = '/Users/anish/Dropbox/KDM-SYN-170906/'
folder_names = aa.getListOfFolders(base_dir)
resolution = {'res_xy_nm': 100, 'res_z_nm': 70}
thresh = 0.9
conjugate_filename_str = 'VDAC'
target_filename_str = 'N152'
conjugate_filenames = []
target_filenames = []
query_list = []
for foldername in folder_names:
target_name = aa.find_filename(target_filename_str, foldername, base_dir)
conjugate_name = aa.find_filename(conjugate_filename_str, foldername, base_dir)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {'preIF': [], 'preIF_z': [],
'postIF': [target_name, conjugate_name], 'postIF_z': [2, 2],
'punctumSize': 2}
query_list.append(query)
measure_list = aa.calculate_measure_lists(query_list, folder_names, base_dir,
thresh, resolution, target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames, conjugate_filenames)
print(df)
return df
def bassoon_L170921_multipleclones3():
""" bassoon_L170921_multipleclones
"""
base_dir = '/Users/anish/Documents/Connectome/Synaptome-Duke/data/antibodyanalysis/L170921-Bassoon/'
folder_names = aa.getListOfFolders(base_dir)
resolution = {'res_xy_nm': 100, 'res_z_nm': 70}
thresh = 0.9
conjugate_filename_str = 'PSD'
conjugate_filename_str2 = 'VGluT1'
target_filename_str = 'L124'
conjugate_filenames = []
target_filenames = []
query_list = []
for foldername in folder_names:
target_name = aa.find_filename(target_filename_str, foldername, base_dir)
conjugate_name = aa.find_filename(conjugate_filename_str, foldername, base_dir)
conjugate_name2 = aa.find_filename(conjugate_filename_str2, foldername, base_dir)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {'preIF': [target_name, conjugate_name2], 'preIF_z': [1, 1],
'postIF': [conjugate_name], 'postIF_z': [1],
'punctumSize': 2}
query_list.append(query)
measure_list = aa.calculate_measure_lists(query_list, folder_names, base_dir,
thresh, resolution, target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames, conjugate_filenames)
print(df)
return df
def COMP():
""" Run antibody characterization tool on the L110-CCK dataset
Return
----------
df : dataframe - contains results
"""
# Location of data
base_dir = "C:/Users/i3x-MM/Desktop/SACT/20180727_NM_Scope/Align" #Location of align tif"
resolution = {'res_xy_nm': 100, 'res_z_nm': 70} #Resolution of a pixel
thresh = 0.9 #What qualifies for final probability map
number_of_datasets = 15 #Number of wells
#Rb Antibody
conjugate_fn_str = 'Synapsin' #String segment to search in a filename
#Ms Antibody project name, no parent or subclone number needed
target_fn_str = 'L124'
#Takes base directory string and gives you an array of all the files within
filenames = aa.getListOfFolders(base_dir)
#
conjugate_filenames = []
target_filenames = []
query_list = []
folder_names = []
for n in range(1, 2):
#Use if dataset missing
#if n == 21: # Dataset 21 does not exist
#continue
print('Well: ', str(n))
folder_names.append('Test-' +
str(n)) # Collate 'dataset' names for excel sheet
conjugate_str = str(
n
) + '-' + conjugate_fn_str #creates filename to search for #Creates n-conjugatename
target_str = str(n) + '-' + target_fn_str
# Search for file associated with the specific dataset number
indices = [
i for i, s in enumerate(filenames)
if conjugate_str == s[0:len(conjugate_str)]
]
conjugate_name = filenames[indices[0]]
print(conjugate_name)
indices = [
i for i, s in enumerate(filenames)
if target_str == s[0:len(target_str)]
]
target_name = filenames[indices[0]]
print(target_name)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
# Create query
#
query = {
'preIF': [conjugate_name],
'preIF_z': [2],
'postIF': [target_name],
'postIF_z': [1],
'punctumSize': 2
}
query_list.append(query)
n = 2
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'PSD' #String segment to search in a filename
target_fn_str = 'K28'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [],
'preIF_z': [],
'postIF': [target_name, conjugate_name],
'postIF_z': [1, 2],
'punctumSize': 2
}
query_list.append(query)
n = 3
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'GAD2' #String segment to search in a filename
target_fn_str = 'L106'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
n = 4
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'Synapsin' #String segment to search in a filename
target_fn_str = 'SP2'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
n = 5
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'PSD' #String segment to search in a filename
target_fn_str = 'SP2'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [],
'preIF_z': [],
'postIF': [target_name, conjugate_name],
'postIF_z': [1, 2],
'punctumSize': 2
}
query_list.append(query)
n = 6
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'GAD2' #String segment to search in a filename
target_fn_str = 'SP2'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
n = 7
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'NP-Rb' #String segment to search in a filename
target_fn_str = 'NP-Ms'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
n = 8
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'NPNS-Rb' #String segment to search in a filename
target_fn_str = 'NPNS-Ms'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
n = 9
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'Synapsin' #String segment to search in a filename
target_fn_str = 'L124'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [conjugate_name],
'preIF_z': [2],
'postIF': [target_name],
'postIF_z': [1],
'punctumSize': 2
}
query_list.append(query)
n = 10
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'PSD' #String segment to search in a filename
target_fn_str = 'K28'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [],
'preIF_z': [],
'postIF': [target_name, conjugate_name],
'postIF_z': [1, 2],
'punctumSize': 2
}
query_list.append(query)
n = 11
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'GAD2' #String segment to search in a filename
target_fn_str = 'L106'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
n = 12
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'Synapsin' #String segment to search in a filename
target_fn_str = 'SP2'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
n = 13
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'PSD' #String segment to search in a filename
target_fn_str = 'SP2'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [],
'preIF_z': [],
'postIF': [target_name, conjugate_name],
'postIF_z': [1, 2],
'punctumSize': 2
}
query_list.append(query)
n = 14
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'GAD2' #String segment to search in a filename
target_fn_str = 'SP2'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
n = 16
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'NPNS-Rb' #String segment to search in a filename
target_fn_str = 'NPNS-Ms'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
# Run all the queries
measure_list = aa.calculate_measure_lists(query_list, None, base_dir,
thresh, resolution,
target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames,
conjugate_filenames)
print(df)
return df
def cask():
""" Run antibody characterization tool on the L110-CCK dataset
Return
----------
df : dataframe - contains results
"""
# Location of data
base_dir = "S:/AIBS_Stanford_for_AT/AT_Plans_and_NM_AT_Images/20171213_JAT_CASK_(K56A)_and_TBS_Comparison/Align_Tiffs" #Location of align tif
resolution = {'res_xy_nm': 100, 'res_z_nm': 70} #Resolution of a pixel
thresh = 0.9 #What qualifies for final probability map
number_of_datasets = 20 #Number of wells
#Rb Antibody
conjugate_fn_str = 'PSD' #String segment to search in a filename
#Ms Antibody project name, no parent or subclone number needed
target_fn_str = 'K56A'
#Takes base directory string and gives you an array of all the files within
filenames = aa.getListOfFolders(base_dir)
#
conjugate_filenames = []
target_filenames = []
query_list = []
folder_names = []
for n in range(1, number_of_datasets + 1):
#Use if dataset missing
#if n == 21: # Dataset 21 does not exist
#continue
print('Well: ', str(n))
folder_names.append('K56A-' + str(n)) # Collate 'dataset' names for excel sheet
conjugate_str = str(n) + '-' + conjugate_fn_str #creates filename to search for #Creates n-conjugatename
target_str = str(n) + '-' + target_fn_str
# Search for file associated with the specific dataset number
indices = [i for i, s in enumerate(filenames) if conjugate_str == s[0:len(conjugate_str)]]
conjugate_name = filenames[indices[0]]
print(conjugate_name)
indices = [i for i, s in enumerate(filenames) if target_str == s[0:len(target_str)]]
target_name = filenames[indices[0]]
print(target_name)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
# Create query
#
query = {'preIF': [target_name, conjugate_name], 'preIF_z': [1,2],
'postIF': [], 'postIF_z': [],
'punctumSize': 2}
query_list.append(query)
n = 21
folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'PSD' #String segment to search in a filename
target_fn_str = 'K28'
conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {'preIF': [target_name,conjugate_name], 'preIF_z': [2,2], 'postIF': [], 'postIF_z': [], 'punctumSize': 2}
query_list.append(query)
# Run all the queries
measure_list = aa.calculate_measure_lists(query_list, None, base_dir,
thresh, resolution, target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames, conjugate_filenames)
print(df)
return df
def isotype_specific():
""" Run antibody characterization tool
L106 is Gephyrin, L120 is Collybistin, L124 is Bassoon and K28 is PSD-95.
1:3 - L106 (Gephyrin) / GAD2
4 - L120 (Collybistin) / GAD2
5 - K28 (PSD95) / PSD95
6 - L124 (Bassoon) / PSD95
7:9 - L106 (Gephyrin) / GAD2
10 - L120 (Collybistin) / GAD2
11 - K28 (PSD95) / PSD95
12 - L124 (Bassoon) / PSD95
Return
----------
df : dataframe - contains results
"""
# Location of data
base_dir = '/Users/anish/Documents/Connectome/Synaptome-Duke/data/antibodyanalysis/Isotype-Specific-Ab-Data/'
resolution = {'res_xy_nm': 100, 'res_z_nm': 70}
thresh = 0.9
number_of_datasets = 12
filenames = aa.getListOfFolders(base_dir)
conjugate_filenames = []
target_filenames = []
query_list = []
folder_names = []
for n in range(1, 4):
folder_names.append(str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'GAD2' # String segment to search in a filename
target_fn_str = 'L106'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str,
filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
# Create query
query = {
'preIF': [target_name],
'preIF_z': [1],
'postIF': [conjugate_name],
'postIF_z': [1],
'punctumSize': 2
}
query_list.append(query)
# Dataset 4
n = 4
folder_names.append(str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'GAD2' # String segment to search in a filename
target_fn_str = 'L120'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name],
'preIF_z': [1],
'postIF': [conjugate_name],
'postIF_z': [1],
'punctumSize': 2
}
query_list.append(query)
# Dataset 5
n = 5
folder_names.append(str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'PSD' # String segment to search in a filename
target_fn_str = 'K28'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [],
'preIF_z': [],
'postIF': [conjugate_name, target_name],
'postIF_z': [1, 1],
'punctumSize': 2
}
query_list.append(query)
# Dataset 6
n = 6
folder_names.append(str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'PSD' # String segment to search in a filename
target_fn_str = 'L124'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [],
'preIF_z': [],
'postIF': [conjugate_name, target_name],
'postIF_z': [1, 1],
'punctumSize': 2
}
query_list.append(query)
# Datasets 7:9
for n in range(7, 10):
folder_names.append(str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'GAD2' # String segment to search in a filename
target_fn_str = 'L106'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str,
filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
# Create query
query = {
'preIF': [target_name],
'preIF_z': [1],
'postIF': [conjugate_name],
'postIF_z': [1],
'punctumSize': 2
}
query_list.append(query)
# Dataset 10
n = 10
folder_names.append(str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'GAD2' # String segment to search in a filename
target_fn_str = 'L120'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name],
'preIF_z': [1],
'postIF': [conjugate_name],
'postIF_z': [1],
'punctumSize': 2
}
query_list.append(query)
# Dataset 11
n = 11
folder_names.append(str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'PSD' # String segment to search in a filename
target_fn_str = 'K28'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [],
'preIF_z': [],
'postIF': [conjugate_name, target_name],
'postIF_z': [1, 1],
'punctumSize': 2
}
query_list.append(query)
# Dataset 12
n = 12
folder_names.append(str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'PSD' # String segment to search in a filename
target_fn_str = 'L124'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [],
'preIF_z': [],
'postIF': [conjugate_name, target_name],
'postIF_z': [1, 1],
'punctumSize': 2
}
query_list.append(query)
# Run all the queries
measure_list = aa.calculate_measure_lists(query_list, None, base_dir,
thresh, resolution,
target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames,
conjugate_filenames)
print(df)
return df
def homer():
""" Run antibody characterization tool on the L113-Homer dataset
Return
----------
df : dataframe - contains results
"""
# Location of data
base_dir = '/Users/anish/Documents/Connectome/Synaptome-Duke/data/antibodyanalysis/neuromab_L113/'
resolution = {'res_xy_nm': 100, 'res_z_nm': 70}
thresh = 0.9
number_of_datasets = 146
conjugate_fn_str = 'psd' # String segment to search in a filename
target_fn_str = 'L113'
filenames = aa.getListOfFolders(base_dir)
conjugate_filenames = []
target_filenames = []
query_list = []
folder_names = []
for n in range(1, number_of_datasets + 1):
# for n in range(1, 3):
if n == 21: # Dataset 21 does not exist
continue
print('Set: ', str(n))
# Collate 'dataset' names for excel sheet
folder_names.append('L113-' + str(n))
# filename to search for
conjugate_str = str(n) + '-' + conjugate_fn_str
target_str = str(n) + '-' + target_fn_str
# Search for file associated with the specific dataset number
indices = [
i for i, s in enumerate(filenames)
if conjugate_str == s[0:len(conjugate_str)]
]
conjugate_name = filenames[indices[0]]
print(conjugate_name)
indices = [
i for i, s in enumerate(filenames)
if target_str == s[0:len(target_str)]
]
target_name = filenames[indices[0]]
print(target_name)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
# Create query
query = {
'preIF': [target_name],
'preIF_z': [2],
'postIF': [conjugate_name],
'postIF_z': [2],
'punctumSize': 2
}
query_list.append(query)
# Run all the queries
measure_list = aa.calculate_measure_lists(query_list, None, base_dir,
thresh, resolution,
target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames,
conjugate_filenames)
print(df)
return df
def NM_Scope():
""" Run antibody characterization tool on the Microscope dataset
Return
----------
df : dataframe - contains results
"""
# Location of data
base_dir = "Z:/AIBS_Stanford_for_AT/AT_Plans_and_NM_AT_Images/20180426_JAT_Microscope_Validation/NM_Scope/NM_Scope_Raw_Align_Tiff" #Location of align tif
resolution = {'res_xy_nm': 100, 'res_z_nm': 70} #Resolution of a pixel
thresh = 0.9 #What qualifies for final probability map
number_of_datasets = 6 #Number of wells
#Rb Antibody
conjugate_fn_str = 'GAD2' #String segment to search in a filename
#Ms Antibody project name, no parent or subclone number needed
target_fn_str = 'L110'
#Takes base directory string and gives you an array of all the files within
filenames = aa.getListOfFolders(base_dir)
#
conjugate_filenames = []
target_filenames = []
query_list = []
folder_names = []
n = 1
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'PSD' #String segment to search in a filename
target_fn_str = 'K28'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [],
'preIF_z': [],
'postIF': [target_name, conjugate_name],
'postIF_z': [1, 2],
'punctumSize': 2
}
query_list.append(query)
n = 2
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'SYNAPSIN' #String segment to search in a filename
target_fn_str = 'K28'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [conjugate_name],
'preIF_z': [2],
'postIF': [target_name],
'postIF_z': [1],
'punctumSize': 2
}
query_list.append(query)
n = 3
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'GAD2' #String segment to search in a filename
target_fn_str = 'L106'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [conjugate_name],
'preIF_z': [2],
'postIF': [target_name],
'postIF_z': [1],
'punctumSize': 2
}
query_list.append(query)
n = 4
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'PSD' #String segment to search in a filename
target_fn_str = 'SP20-PSD95'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [],
'preIF_z': [],
'postIF': [target_name, conjugate_name],
'postIF_z': [1, 2],
'punctumSize': 2
}
query_list.append(query)
n = 5
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'SYNAPSIN' #String segment to search in a filename
target_fn_str = 'SP20-SYNAPSIN1'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
n = 6
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'GAD2' #String segment to search in a filename
target_fn_str = 'SP20-GAD2'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 2],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
n = 7
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'NP-RB' #String segment to search in a filename
target_fn_str = 'NP-MS'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 1],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
n = 8
folder_names.append('Control' +
str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'NPNS-RB' #String segment to search in a filename
target_fn_str = 'NPNS-MS'
conjugate_name, target_name = aa.findFilenames(reference_fn_str,
target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {
'preIF': [target_name, conjugate_name],
'preIF_z': [1, 1],
'postIF': [],
'postIF_z': [],
'punctumSize': 2
}
query_list.append(query)
# Run all the queries
measure_list = aa.calculate_measure_lists(query_list, None, base_dir,
thresh, resolution,
target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames,
conjugate_filenames)
print(df)
return df
def NAME():
""" Run antibody characterization tool on the L110-CCK dataset
Return
----------
df : dataframe - contains results
"""
# Location of data
base_dir = "(Location)" #Location of align tif --> Should be the location of the experiment's align tiff folder, ex: "C/desktop/work/image_processing/YYYYMMDD/align_tiffs"
resolution = {'res_xy_nm': 100, 'res_z_nm': 70} #Resolution of a pixel (do not alter)
thresh = 0.9 #What qualifies for final probability map (do not alter)
number_of_datasets = 20 #Number of wells in the experiemnts, "20" is an example where there are 16 samples and 4 controls
#Rb Antibody
conjugate_fn_str = 'GAD2' #String segment to search in a filename
#conjugate_fn_str should be the term used in the name of the control align tiff for a well (usually "PSD", "GAD2", or "SYNAPSIN")
target_fn_str = 'L106'
#Ms Antibody project name, no parent or subclone number needed
#target_fn_str should be the project number, for instance if this was testing L109 samples, this would be "L109"
#Takes base directory string and gives you an array of all the files within
filenames = aa.getListOfFolders(base_dir) #Do not change
conjugate_filenames = [] #Do not change
target_filenames = [] #Do not change
query_list = [] #Do not change
folder_names = [] #Do not change
for n in range(1, 17):
#Use if dataset missing
#This is where you put in the rangee of wells used as your test samples
#Since we have 16 samples that are test samples for L106, the range is equal to 1 through n+1, or 1 through 17
#If your test samples do not begin at well 1, then adjust the beginning of the range accordingly (3 through 17 if the first test sample is in well 3)
#continue
print('Well: ', str(n)) #Do not change
folder_names.append('Test-' + str(n)) # Collate 'dataset' names for excel sheet #Do not change
conjugate_str = str(n) + '-' + conjugate_fn_str #creates filename to search for #Creates n-conjugatename #Do not change
target_str = str(n) + '-' + target_fn_str #Do not change
# Search for file associated with the specific dataset number
indices = [i for i, s in enumerate(filenames) if conjugate_str == s[0:len(conjugate_str)]] #Do not change
conjugate_name = filenames[indices[0]] #Do not change
print(conjugate_name) #Do not change
indices = [i for i, s in enumerate(filenames) if target_str == s[0:len(target_str)]] #Do not change
target_name = filenames[indices[0]] #Do not change
print(target_name) #Do not change
conjugate_filenames.append(conjugate_name) #Do not change
target_filenames.append(target_name) #Do not change
# Create query
#
query = {'preIF': [conjugate_name], 'preIF_z': [2],
'postIF': [target_name], 'postIF_z': [1],
'punctumSize': 2}
#preIF = items that are presynaptic targets go here, because GAD2, our conjugate, is presynaptic I put the conjugate_name in this box
#preIF_z = how many tiffs a puncta must be in to be registered, conjugate sample number is 2 so 2 goes in this box
#postIF = items that are postsynaptic targets go here, L106 is postsynaptic so I put target_name here
#postIF_z = how many tiffs a puncta must be in to be registered, target sample number is 1 (for now unless changed later)
#punctumSize = size of punctum the algorithm is looking for, do not change unless directed to
"""Example of a presynaptic target and presynaptic conjugate
query = {'preIF': [target_name,conjugate_name], 'preIF_z': [1,2],
'postIF': [], 'postIF_z': [],
'punctumSize': 2}"""
"""Example of a postsynaptic target and presynaptic conjugate
query = {'preIF': [conjugate_name], 'preIF_z': [2],
'postIF': [target_name], 'postIF_z': [1],
'punctumSize': 2}"""
"""Example of a postsynaptic target and postsynaptic conjugate
query = {'preIF': [], 'preIF_z': [],
'postIF': [target_name,conjugate_name], 'postIF_z': [1,2],
'punctumSize': 2}"""
"""Example of a presynaptic target and postsynaptic conjugate
query = {'preIF': [target_name], 'preIF_z': [1],
'postIF': [conjugate_name], 'postIF_z': [2],
'punctumSize': 2}"""
query_list.append(query)
#The following n samples are controls - you can add as many of these as you want by copying the block of code and pasting it after the last one
#The notes in the following block of code apply to all of the controls
n = 17 #well number of control sample
folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet #Do not change
reference_fn_str = 'GAD2' #String segment to search in a filename #refernce_fn_str is the project number/name of RB control
target_fn_str = 'L106' #target_fn_str is the project number of the Ms control you are using
conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n) #Do not alter
conjugate_filenames.append(conjugate_name) #Do not alter
target_filenames.append(target_name) #Do not alter
query = {'preIF': [conjugate_name], 'preIF_z': [2], 'postIF': [target_name], 'postIF_z': [1], 'punctumSize': 2} #Se the examples and explanations above about "query"
query_list.append(query) #Do not change
n = 18
folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'GAD2' #String segment to search in a filename
target_fn_str = 'SP2'
conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {'preIF': [target_name,conjugate_name], 'preIF_z': [1,2], 'postIF': [], 'postIF_z': [], 'punctumSize': 2}
query_list.append(query)
n = 19
folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'NP-RB' #String segment to search in a filename
target_fn_str = 'NP-MS'
conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {'preIF': [], 'preIF_z': [], 'postIF': [target_name,conjugate_name], 'postIF_z': [1,2], 'punctumSize': 2}
query_list.append(query)
n = 20
folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet
reference_fn_str = 'NPNS-RB' #String segment to search in a filename
target_fn_str = 'NPNS-MS'
conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
query = {'preIF': [], 'preIF_z': [], 'postIF': [target_name,conjugate_name], 'postIF_z': [1,2], 'punctumSize': 2}
query_list.append(query)
measure_list = aa.calculate_measure_lists(query_list, None, base_dir,
thresh, resolution, target_filenames) # Run all the queries
df = aa.create_df(measure_list, folder_names, target_filenames, conjugate_filenames) #Do not change
print(df) #Do not change
return df #Do not change
def N452():
""" Run antibody characterization tool on the L110-CCK dataset
Return
----------
df : dataframe - contains results
"""
# Location of data
base_dir = "C:/Users/stjst/Desktop/Work/Image_Processing/20180202_N452/Align" #Location of align tif"
resolution = {'res_xy_nm': 100, 'res_z_nm': 70} #Resolution of a pixel
thresh = 0.9 #What qualifies for final probability map
number_of_datasets = 20 #Number of wells
#Rb Antibody
conjugate_fn_str = 'GAD2' #String segment to search in a filename
#Ms Antibody project name, no parent or subclone number needed
target_fn_str = 'N452'
#Takes base directory string and gives you an array of all the files within
filenames = aa.getListOfFolders(base_dir)
#
conjugate_filenames = []
target_filenames = []
query_list = []
folder_names = []
for n in range(1, 20):
#Use if dataset missing
#if n == 21: # Dataset 21 does not exist
#continue
print('Well: ', str(n))
folder_names.append('Test-' +
str(n)) # Collate 'dataset' names for excel sheet
conjugate_str = str(
n
) + '-' + conjugate_fn_str #creates filename to search for #Creates n-conjugatename
target_str = str(n) + '-' + target_fn_str
# Search for file associated with the specific dataset number
indices = [
i for i, s in enumerate(filenames)
if conjugate_str == s[0:len(conjugate_str)]
]
conjugate_name = filenames[indices[0]]
print(conjugate_name)
indices = [
i for i, s in enumerate(filenames)
if target_str == s[0:len(target_str)]
]
target_name = filenames[indices[0]]
print(target_name)
conjugate_filenames.append(conjugate_name)
target_filenames.append(target_name)
# Create query
#
query = {
'preIF': [conjugate_name],
'preIF_z': [2],
'postIF': [target_name],
'postIF_z': [1],
'punctumSize': 2
}
query_list.append(query)
# Run all the queries
measure_list = aa.calculate_measure_lists(query_list, None, base_dir,
thresh, resolution,
target_filenames)
df = aa.create_df(measure_list, folder_names, target_filenames,
conjugate_filenames)
print(df)
return df
