def upgrade_settings(self, setting_values, variable_revision_number,
module_name):
if variable_revision_number == 1:
setting_values = (setting_values[:5] +
[cpprefs.get_default_image_directory()] +
setting_values[5:])
variable_revision_number = 2
if variable_revision_number == 2:
setting_values = (
setting_values[:6] +
[int(re.sub(r"\.|rc\d{1}", "", cellprofiler.__version__))] +
setting_values[6:])
variable_revision_number = 3
if variable_revision_number == 3:
# Pickled image list is now the batch state
self.batch_state = np.array(zlib.compress(setting_values[4]))
setting_values = setting_values[:4] + setting_values[5:]
variable_revision_number = 4
if variable_revision_number == 4:
setting_values = setting_values[:4] + [False] + setting_values[4:]
variable_revision_number = 5
if variable_revision_number == 5:
# added from_old_matlab
setting_values = setting_values[:7] + [False] + setting_values[7:]
variable_revision_number = 6
if variable_revision_number == 6:
# added go_to_website
setting_values = setting_values[:8] + [False] + setting_values[8:]
variable_revision_number = 7
if variable_revision_number == 7:
setting_values = setting_values[:8] + setting_values[9:]
variable_revision_number = 8
return setting_values, variable_revision_number
def create_settings(self):
"""Create the module settings and name the module"""
self.wants_default_output_directory = cps.Binary(
"Store batch files in default output folder?",
True,
doc="""\
Select "*Yes*" to store batch files in the Default Output folder.
Select "*No*" to enter the path to the folder that will be used to
store these files. The Default Output folder can be set by clicking the "View output settings" button in the main CP window, or in CellProfiler Preferences. """
% globals(),
)
self.custom_output_directory = cps.Text(
"Output folder path",
cpprefs.get_default_output_directory(),
doc=
"Enter the path to the output folder. (Used only if not using the default output folder)",
)
# Worded this way not because I am windows-centric but because it's
# easier than listing every other OS in the universe except for VMS
self.remote_host_is_windows = cps.Binary(
"Are the cluster computers running Windows?",
False,
doc="""\
Select "*Yes*" if the cluster computers are running one of the
Microsoft Windows operating systems. In this case, **CreateBatchFiles**
will modify all paths to use the Windows file separator (backslash \\\\ ).
Select "*No*" for **CreateBatchFiles** to modify all paths to use the
Unix or Macintosh file separator (slash / ).""" % globals(),
)
self.batch_mode = cps.Binary("Hidden: in batch mode", False)
self.distributed_mode = cps.Binary("Hidden: in distributed mode",
False)
self.default_image_directory = cps.Setting(
"Hidden: default input folder at time of save",
cpprefs.get_default_image_directory(),
)
self.revision = cps.Integer("Hidden: revision number", 0)
self.from_old_matlab = cps.Binary("Hidden: from old matlab", False)
self.acknowledge_old_matlab = cps.DoSomething(
"Could not update CP1.0 pipeline to be compatible with CP2.0. See module notes.",
"OK",
self.clear_old_matlab,
)
self.mappings = []
self.add_mapping()
self.add_mapping_button = cps.DoSomething(
"",
"Add another path mapping",
self.add_mapping,
doc="""\
Use this option if another path must be mapped because there is a difference
between how the local computer sees a folder location vs. how the cluster
computer sees the folder location.""",
)
def __init__(self, parent_sizer, panel, progress_panel, status_panel):
self.__panel = panel
self.__parent_sizer = parent_sizer
panel.AutoLayout = True
panel.SetSizer(wx.BoxSizer(wx.VERTICAL))
static_box_sizer = wx.BoxSizer(wx.VERTICAL)
panel.Sizer.Add(static_box_sizer, 1, wx.EXPAND)
self.__sizer = static_box_sizer
self.__image_folder_panel = wx.Panel(panel)
self.__image_folder_panel.SetAutoLayout(True)
self.__image_edit_box = self.__make_folder_panel(
self.__image_folder_panel,
get_default_image_directory(),
lambda: get_recent_files(DEFAULT_IMAGE_DIRECTORY),
"Default Input Folder",
DEFAULT_IMAGE_FOLDER_HELP,
[
set_default_image_directory,
self.__notify_pipeline_list_view_directory_change,
],
refresh_action=self.refresh_input_directory,
)
self.__output_folder_panel = wx.Panel(panel)
self.__output_folder_panel.SetAutoLayout(True)
self.__output_edit_box = self.__make_folder_panel(
self.__output_folder_panel,
get_default_output_directory(),
lambda: get_recent_files(DEFAULT_OUTPUT_DIRECTORY),
"Default Output Folder",
DEFAULT_OUTPUT_FOLDER_HELP,
[
set_default_output_directory,
self.__notify_pipeline_list_view_directory_change,
],
)
self.__odds_and_ends_panel = wx.Panel(panel)
self.__odds_and_ends_panel.SetAutoLayout(True)
self.__make_odds_and_ends_panel()
self.__status_panel = status_panel
status_panel.Sizer = wx.BoxSizer()
self.__status_text = wx.StaticText(status_panel,
style=wx.SUNKEN_BORDER,
label=WELCOME_MESSAGE)
status_panel.Sizer.Add(self.__status_text, 1, wx.EXPAND)
self.__progress_panel = progress_panel
self.__progress_panel.AutoLayout = True
self.__make_progress_panel()
self.__sizer.AddMany([
(self.__image_folder_panel, 0, wx.EXPAND | wx.ALL, 1),
(self.__output_folder_panel, 0, wx.EXPAND | wx.ALL, 1),
(self.__odds_and_ends_panel, 0, wx.EXPAND | wx.ALL, 1),
])
self.show_status_text()
self.__errors = set()
self.__pipeline_list_view = None
self.__progress_watcher = None
def save_default_folders_to_measurements(self):
from ..constants.pipeline import M_DEFAULT_INPUT_FOLDER
from ..constants.pipeline import M_DEFAULT_OUTPUT_FOLDER
from cellprofiler_core.preferences import get_default_image_directory
from cellprofiler_core.preferences import get_default_output_directory
self.measurements.add_experiment_measurement(
M_DEFAULT_INPUT_FOLDER, get_default_image_directory())
self.measurements.add_experiment_measurement(
M_DEFAULT_OUTPUT_FOLDER, get_default_output_directory())
def save_pipeline(self, workspace, outf=None):
"""Save the pipeline in Batch_data.mat
Save the pickled image_set_list state in a setting and put this
module in batch mode.
if outf is not None, it is used as a file object destination.
"""
if outf is None:
if self.wants_default_output_directory.value:
path = cpprefs.get_default_output_directory()
else:
path = cpprefs.get_absolute_path(
self.custom_output_directory.value)
h5_path = os.path.join(path, F_BATCH_DATA_H5)
else:
h5_path = outf
image_set_list = workspace.image_set_list
pipeline = workspace.pipeline
m = cpmeas.Measurements(copy=workspace.measurements, filename=h5_path)
try:
assert isinstance(pipeline, cpp.Pipeline)
assert isinstance(m, cpmeas.Measurements)
orig_pipeline = pipeline
pipeline = pipeline.copy()
# this use of workspace.frame is okay, since we're called from
# prepare_run which happens in the main wx thread.
target_workspace = cpw.Workspace(pipeline, None, None, None, m,
image_set_list, workspace.frame)
pipeline.prepare_to_create_batch(target_workspace, self.alter_path)
bizarro_self = pipeline.module(self.module_num)
bizarro_self.revision.value = int(
re.sub(r"\.|rc\d{1}", "", cellprofiler.__version__))
if self.wants_default_output_directory:
bizarro_self.custom_output_directory.value = self.alter_path(
cpprefs.get_default_output_directory())
bizarro_self.default_image_directory.value = self.alter_path(
cpprefs.get_default_image_directory())
bizarro_self.batch_mode.value = True
pipeline.write_pipeline_measurement(m)
orig_pipeline.write_pipeline_measurement(m, user_pipeline=True)
#
# Write the path mappings to the batch measurements
#
m.write_path_mappings([(mapping.local_directory.value,
mapping.remote_directory.value)
for mapping in self.mappings])
return h5_path
finally:
m.close()
def estimate_absorbance(self):
"""Load an image and use it to estimate the absorbance of a stain
Returns a 3-tuple of the R/G/B absorbances
"""
from cellprofiler_core.image import FileImage
import wx
dlg = wx.FileDialog(None, "Choose reference image",
get_default_image_directory())
dlg.Wildcard = (
"Image file (*.tif, *.tiff, *.bmp, *.png, *.gif, *.jpg)|"
"*.tif;*.tiff;*.bmp;*.png;*.gif;*.jpg")
if dlg.ShowModal() == wx.ID_OK:
lip = FileImage("dummy", "", dlg.Path)
image = lip.provide_image(None).pixel_data
if image.ndim < 3:
wx.MessageBox(
"You must calibrate the absorbance using a color image",
"Error: not color image",
style=wx.OK | wx.ICON_ERROR,
)
return None
#
# Log-transform the image
#
eps = 1.0 / 256.0 / 2.0
log_image = numpy.log(image + eps)
data = [-log_image[:, :, i].flatten() for i in range(3)]
#
# Order channels by strength
#
sums = [numpy.sum(x) for x in data]
order = numpy.lexsort([sums])
#
# Calculate relative absorbance against the strongest.
# Fit Ax = y to find A where x is the strongest and y
# is each in turn.
#
strongest = data[order[-1]][:, numpy.newaxis]
absorbances = [
scipy.linalg.lstsq(strongest, d)[0][0] for d in data
]
#
# Normalize
#
absorbances = numpy.array(absorbances)
return absorbances / numpy.sqrt(numpy.sum(absorbances**2))
return None
def prepare_run(self, workspace):
"""Set up omero image providers inside the image_set_list"""
pipeline = workspace.pipeline
image_set_list = workspace.image_set_list
if pipeline.in_batch_mode():
# TODO: Rewrite the OmeroImageProvider such that it can be used in batch mode
# e.g., omero session keys could be used to attach to existing sessions to
# keep OmeroImageProviders from creating a new session every time an image should be loaded
return False
if cpp.get_headless():
print(
"OmeroLoadImages running in headless mode: image directory parameter will be used as omero object id"
)
self.omero_object_id.set_value(
int(cpp.get_default_image_directory()))
print("omero object id = %d" % self.omero_object_id.value)
print("omero object type = %s" % self.omero_object.value)
self.create_omero_gateway()
if self.omero_object == MS_IMAGE:
omero_image_list = [
self.omero_gateway.getImage(self.omero_object_id.value)
]
elif self.omero_object == MS_DATASET:
# Get dataset without leaves(=images&pixels)
dataset = self.omero_gateway.getDataset(self.omero_object_id.value,
False)
self.dataset_name = dataset.getName().getValue()
omero_image_list = self.get_images_from_dataset(
self.omero_object_id.value)
elif self.omero_object == MS_PLATE:
self.wells = self.get_wells_from_plate(self.omero_object_id.value)
self.plate_name = self.wells[0].getPlate().getName().getValue()
omero_image_list = []
for well in self.wells:
for wellsample in well.iterateWellSamples():
omero_image_list.append(wellsample.getImage())
# get names and pixels from omero images
pixels_list = []
for omero_image in omero_image_list:
image_id = omero_image.getId().getValue()
pixels_list += self.omero_gateway.getPixelsFromImage(image_id)
# add images to image sets
image_set_count = len(pixels_list)
for i in range(0, image_set_count):
image_set = image_set_list.get_image_set(i)
pixels = pixels_list[i]
pixels_id = pixels.getId().getValue()
sizeZ = pixels.getSizeZ().getValue()
sizeC = pixels.getSizeC().getValue()
sizeT = pixels.getSizeT().getValue()
for channel in self.channels:
for z in range(0, sizeZ):
for t in range(0, sizeT):
c = int(channel.channel_number.value)
self.save_image_set_info(
image_set,
channel.cpimage_name.value,
P_OMERO,
V_OMERO,
self.omero_gateway,
pixels_id,
z,
c,
t,
)
return True
def add_mapping(self):
group = cps.SettingsGroup()
group.append(
"local_directory",
cps.Text(
"Local root path",
cpprefs.get_default_image_directory(),
doc="""\
Enter the path to files on this computer. This is the root path on the
local machine (i.e., the computer setting up the batch files).
For instance, a Windows machine might access files images by mounting the file system using a drive
letter, like this:
``Z:\your_data\images``
and the cluster computers access the same file system like this:
``/server_name/your_name/your_data/images``
In this case, since the ``your_data\images`` portion of the path is
the same for both, the local root path is the portion prior, i.e.,
``Z:\`` and similarly for the cluster root path, i.e.,
``/server_name/your_name/``.
If **CreateBatchFiles** finds any pathname that matches the local root path
at the beginning, it will replace that matching portion with the cluster root path.
For example, if you have mapped the remote cluster machine like this:
``Z:\your_data\images``
(on a Windows machine, for instance) and the cluster machine sees the same folder like this:
``/server_name/your_name/your_data/images``
you would enter ``Z:\`` here for the local root path and ``/server_name/your_name/`` for the
cluster root path in the next setting.""",
),
)
group.append(
"remote_directory",
cps.Text(
"Cluster root path",
cpprefs.get_default_image_directory(),
doc="""\
Enter the path to files on the cluster. This is the cluster root path,
i.e., how the cluster machine sees the top-most folder where your
input/output files are stored.
For instance, a Windows machine might access files images by mounting the file system using a drive
letter, like this:
``Z:\your_data\images``
and the cluster computers access the same file system like this:
``/server_name/your_name/your_data/images``
In this case, since the ``your_data\images`` portion of the path is
the same for both, the local root path is the portion prior, i.e.,
``Z:\`` and similarly for the cluster root path, i.e.,
``/server_name/your_name/``.
If **CreateBatchFiles** finds any pathname that matches the local root path
at the beginning, it will replace that matching portion with the cluster root path.
For example, if you have mapped the remote cluster machine like this:
``Z:\your_data\images``
(on a Windows machine, for instance) and the cluster machine sees the same folder like this:
``/server_name/your_name/your_data/images``
you would enter ``Z:\`` in the previous setting for the local root
path and ``/server_name/your_name/`` here for the cluster root path.""",
),
)
group.append(
"remover",
cps.RemoveSettingButton("", "Remove this path mapping",
self.mappings, group),
)
group.append("divider", cps.Divider(line=False))
self.mappings.append(group)
def __on_preferences_image_directory_event(self, event):
if self.__image_edit_box.GetValue() != get_default_image_directory():
self.__image_edit_box.SetValue(get_default_image_directory())
