diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..25d25dd --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,9 @@ +--- +# Set update schedule for GitHub Actions dependencies +version: 2 +updates: + + - package-ecosystem: "pip" + directory: "/" + schedule: + interval: "weekly" \ No newline at end of file diff --git a/.github/workflows/build-docs.yml b/.github/workflows/build-docs.yml new file mode 100644 index 0000000..711975c --- /dev/null +++ b/.github/workflows/build-docs.yml @@ -0,0 +1,33 @@ +name: Documentation + +on: + push: + branches: + - main + +jobs: + docs: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2.3.1 + with: + persist-credentials: false + - name: Set up Python + uses: actions/setup-python@0a5c61591373683505ea898e09a3ea4f39ef2b9c + with: + python-version: 3.9 + - name: Install Dependencies + run: | + pip install --upgrade pip + pip install .[dev] + - name: Generate Docs + run: | + make gen-docs + touch docs/_build/html/.nojekyll + - name: Publish Docs + uses: JamesIves/github-pages-deploy-action@3.7.1 + with: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + BASE_BRANCH: main # The branch the action should deploy from. + BRANCH: gh-pages # The branch the action should deploy to. + FOLDER: docs/_build/html/ # The folder the action should deploy. \ No newline at end of file diff --git a/.github/workflows/build-master.yml b/.github/workflows/build-master.yml index ae9f005..0ed2eec 100644 --- a/.github/workflows/build-master.yml +++ b/.github/workflows/build-master.yml @@ -1,54 +1,74 @@ # name: Build Master -# on: -# push: -# branches: -# - master -# schedule: -# # -# # https://pubs.opengroup.org/onlinepubs/9699919799/utilities/crontab.html#tag_20_25_07 -# # Run every Monday at 18:00:00 UTC (Monday at 10:00:00 PST) -# - cron: '0 18 * * 1' +on: + push: + branches: + - master -# jobs: -# test: -# runs-on: ${{ matrix.os }} -# strategy: -# matrix: -# python-version: [3.7, 3.8] -# os: [ubuntu-latest, macOS-latest] +jobs: + test: + runs-on: ${{ matrix.os }} + strategy: + matrix: + python-version: ["3.9", "3.10", "3.11"] + os: [ubuntu-latest, windows-latest, macOS-latest] -# steps: -# - uses: actions/checkout@v1 -# - name: Set up Python ${{ matrix.python-version }} -# uses: actions/setup-python@v1 -# with: -# python-version: ${{ matrix.python-version }} -# - name: Install Dependencies -# run: | -# python -m pip install --upgrade pip -# pip install .[test] -# - name: Test with pytest -# run: | -# pytest --cov-report xml --cov=cvapipe_analysis cvapipe_analysis/tests/ -# codecov -t ${{ secrets.CODECOV_TOKEN }} + steps: + - uses: actions/checkout@v1 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@0a5c61591373683505ea898e09a3ea4f39ef2b9c + with: + python-version: ${{ matrix.python-version }} + - name: Install Dependencies + run: | + python -m pip install --upgrade pip + pip install .[test] + - name: Test with pytest + run: | + pytest --cov-report xml --cov=cvapipe_analysis cvapipe_analysis/tests/ + - name: Upload codecov + uses: codecov/codecov-action@v1 # lint: # runs-on: ubuntu-latest -# steps: -# - uses: actions/checkout@v1 -# - name: Set up Python -# uses: actions/setup-python@v1 -# with: -# python-version: 3.8 -# - name: Install Dependencies -# run: | -# python -m pip install --upgrade pip -# pip install .[test] -# - name: Lint with flake8 -# run: | -# flake8 cvapipe_analysis --count --verbose --show-source --statistics -# - name: Check with black -# run: | -# black --check cvapipe_analysis + steps: + - uses: actions/checkout@v1 + - name: Set up Python + uses: actions/setup-python@0a5c61591373683505ea898e09a3ea4f39ef2b9c + with: + python-version: 3.9 + - name: Install Dependencies + run: | + python -m pip install --upgrade pip + pip install .[test] + - name: Lint with flake8 + run: | + flake8 cvapipe_analysis --count --verbose --show-source --statistics + - name: Check with black + run: | + black --check cvapipe_analysis + + publish: + if: "contains(github.event.head_commit.message, 'Bump version')" + needs: [test, lint] + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v1 + - name: Set up Python + uses: actions/setup-python@0a5c61591373683505ea898e09a3ea4f39ef2b9c + with: + python-version: 3.9 + - name: Install Dependencies + run: | + python -m pip install --upgrade pip + pip install setuptools wheel + - name: Build Package + run: | + python setup.py sdist bdist_wheel + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@master + with: + user: __token__ + password: ${{ secrets.PYPI_TOKEN }} \ No newline at end of file diff --git a/.github/workflows/test-and-lint.yml b/.github/workflows/test-and-lint.yml index 3cbd328..905e51c 100644 --- a/.github/workflows/test-and-lint.yml +++ b/.github/workflows/test-and-lint.yml @@ -2,44 +2,46 @@ # on: pull_request -# jobs: -# test: -# runs-on: ${{ matrix.os }} -# strategy: -# matrix: -# python-version: [3.7, 3.8] -# os: [ubuntu-latest, macOS-latest] +jobs: + test: + runs-on: ${{ matrix.os }} + strategy: + matrix: + python-version: ["3.9", "3.10", "3.11"] + os: [ubuntu-latest, windows-latest, macOS-latest] -# steps: -# - uses: actions/checkout@v1 -# - name: Set up Python ${{ matrix.python-version }} -# uses: actions/setup-python@v1 -# with: -# python-version: ${{ matrix.python-version }} -# - name: Install Dependencies -# run: | -# python -m pip install --upgrade pip -# pip install .[test] -# - name: Test with pytest -# run: | -# pytest cvapipe_analysis/tests/ + steps: + - uses: actions/checkout@v1 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@0a5c61591373683505ea898e09a3ea4f39ef2b9c + with: + python-version: ${{ matrix.python-version }} + - name: Install Dependencies + run: | + python -m pip install --upgrade pip + pip install .[test] + - name: Test with pytest + run: | + pytest cvapipe_analysis/tests/ + - name: Upload codecov + uses: codecov/codecov-action@v1 # lint: # runs-on: ubuntu-latest -# steps: -# - uses: actions/checkout@v1 -# - name: Set up Python -# uses: actions/setup-python@v1 -# with: -# python-version: 3.8 -# - name: Install Dependencies -# run: | -# python -m pip install --upgrade pip -# pip install .[test] -# - name: Lint with flake8 -# run: | -# flake8 cvapipe_analysis --count --verbose --show-source --statistics -# - name: Check with black -# run: | -# black --check cvapipe_analysis + steps: + - uses: actions/checkout@v1 + - name: Set up Python + uses: actions/setup-python@0a5c61591373683505ea898e09a3ea4f39ef2b9c + with: + python-version: 3.9 + - name: Install Dependencies + run: | + python -m pip install --upgrade pip + pip install .[test] + - name: Lint with flake8 + run: | + flake8 cvapipe_analysis --count --verbose --show-source --statistics + - name: Check with black + run: | + black --check cvapipe_analysis \ No newline at end of file diff --git a/.gitignore b/.gitignore index 18d765c..20b84fc 100644 --- a/.gitignore +++ b/.gitignore @@ -121,3 +121,9 @@ ENV/ .mypy_cache/ workflow_config.json .distribute/* + +# results +*.png +*.pdf +*.vtk +*.gif \ No newline at end of file diff --git a/README.md b/README.md index c5f8e25..0c51950 100644 --- a/README.md +++ b/README.md @@ -2,6 +2,10 @@ ## Analysis Pipeline for Cell Variance +[![Build Status](https://github.com/AllenCell/cvapipe_analysis/workflows/Build%20Main/badge.svg)](https://github.com/AllenCell/cvapipe_analysis/actions) +[![Documentation](https://github.com/AllenCell/cvapipe_analysis/workflows/Documentation/badge.svg)](https://AllenCell.github.io/cvapipe_analysis/) + + ![Shape modes](docs/logo.png) --- diff --git a/codecov.yml b/codecov.yml deleted file mode 100644 index 03d8bc1..0000000 --- a/codecov.yml +++ /dev/null @@ -1,8 +0,0 @@ -ignore: - - "**/__init__.py" - - "cvapipe_analysis/bin/.*" - - "cvapipe_analysis/vendor/.*" - -coverage: - status: - patch: off diff --git a/config.yaml b/config.yaml deleted file mode 100644 index 67b7ede..0000000 --- a/config.yaml +++ /dev/null @@ -1,129 +0,0 @@ -appName: cvapipe_analysis - -project: - local_staging: "your_path_to/local_staging_variance" - overwrite: off - -data: - cell: - alias: MEM - channel: membrane_segmentation - color: '#F200FF' - cell-roof: - alias: MEMROOF - channel: membrane_segmentation_roof - color: '#F200FF' - nucleus: - alias: NUC - channel: dna_segmentation - color: '#3AADA7' - structure: - alias: STR - channel: struct_segmentation_roof - color: '#000000' - raw-structure-str: - alias: RAWSTR_MASKEDBY_STR - channel: structure - color: '#000000' - raw-structure-nuc: - alias: RAWSTR_MASKEDBY_NUC - channel: structure - color: '#000000' - raw-structure-mem: - alias: RAWSTR_MASKEDBY_MEM - channel: structure - color: '#000000' - -features: - aliases: ["NUC", "MEM", "STR", "RAWSTR_MASKEDBY_STR", "RAWSTR_MASKEDBY_NUC", "RAWSTR_MASKEDBY_MEM"] - # Intensity features: specify aliases for raw image and - # corresponding segmentation mask. - intensity: - RAWSTR_MASKEDBY_STR: STR - RAWSTR_MASKEDBY_NUC: NUC - RAWSTR_MASKEDBY_MEM: MEMROOF - # SHE - Spherical harmonics expansion - SHE: - alignment: - align: on - unique: off - reference: "cell" - aliases: ["NUC", "MEM"] - # Size of Gaussian kernal used to smooth the - # images before SHE coefficients calculation - sigma: - MEM: 2 - NUC: 2 - # Number of SHE coefficients used to describe cell - # and nuclear shape - lmax: 16 - -preprocessing: - remove_mitotics: on - remove_outliers: on - filtering: - filter: off - csv: "" - specs: {} - -shapespace: - # Specify the a set of aliases here - aliases: ["NUC", "MEM"] - # Sort shape modes by volume of - sorter: "MEM" - # Percentage of exteme points to be removed - removal_pct: 1.0 - # Number of principal components to be calculated - number_of_shape_modes: 8 - # Map points - map_points: [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0] - plot: - frame: on - swapxy_on_zproj: off - # limits of x and y axies in the animated GIFs - limits: [-150, 150, -80, 80] - -parameterization: - inner: "NUC" - outer: "MEM" - parameterize: ["STR"] - number_of_interpolating_points: 32 - -aggregation: - type: ['avg'] - -structures: - "FBL": ["nucleoli [DFC)", "#A9D1E5", "{'raw': (420, 2610), 'seg': (0,30), 'avgseg': (80,160)}"] - "NPM1": ["nucleoli [GC)", "#88D1E5", "{'raw': (480, 8300), 'seg': (0,30), 'avgseg': (80,160)}"] - "SON": ["nuclear speckles", "#3292C9", "{'raw': (420, 1500), 'seg': (0,10), 'avgseg': (10,60)}"] - "SMC1A": ["cohesins", "#306598", "{'raw': (450, 630), 'seg': (0,2), 'avgseg': (0,15)}"] - "HIST1H2BJ": ["histones", "#305098", "{'raw': (450, 2885), 'seg': (0,30), 'avgseg': (10,100)}"] - "LMNB1": ["nuclear envelope", "#084AE7", "{'raw': (475,1700), 'seg': (0,30), 'avgseg': (0,60)}"] - "NUP153": ["nuclear pores", "#0840E7", "{'raw': (420, 600), 'seg': (0,15), 'avgseg': (0,50)}"] - "SEC61B": ["ER [Sec61 beta)", "#FFFFB5", "{'raw': (490,1070), 'seg': (0,30), 'avgseg': (0,100)}"] - "ATP2A2": ["ER [SERCA2)", "#FFFFA0", "{'raw': (430,670), 'seg': (0,25), 'avgseg': (0,80)}"] - "SLC25A17": ["peroxisomes", "#FFD184", "{'raw': (400,515), 'seg': (0,7), 'avgseg': (0,15)}"] - "RAB5A": ["endosomes", "#FFC846", "{'raw': (420,600), 'seg': (0,7), 'avgseg': (0,10)}"] - "TOMM20": ["mitochondria", "#FFBE37", "{'raw': (410,815), 'seg': (0,27), 'avgseg': (0,50)}"] - "LAMP1": ["lysosomes", "#AD952A", "{'raw': (440,800), 'seg': (0,27), 'avgseg': (0,30)}"] - "ST6GAL1": ["Golgi", "#B7952A", "{'raw': (400,490), 'seg': (0,17), 'avgseg': (0,30)}"] - "TUBA1B": ["microtubules", "#9D7000", "{'raw': (1100,3200), 'seg': (0,22), 'avgseg': (0,60)}"] - "CETN2": ["centrioles", "#C8E1AA", "{'raw': (440,800), 'seg': (0, 2), 'avgseg': (0,2)}"] - "GJA1": ["gap junctions", "#BEE18C", "{'raw': (420,2200), 'seg': (0,4), 'avgseg': (0,8)}"] - "TJP1": ["tight junctions", "#B4C878", "{'raw': (420,1500), 'seg': (0,8), 'avgseg': (0,20)}"] - "DSP": ["desmosomes", "#B4C864", "{'raw': (410,620), 'seg': (0,5), 'avgseg': (0,3)}"] - "CTNNB1": ["adherens junctions", "#96AA46", "{'raw': (410,750), 'seg': (0,22), 'avgseg': (5,40)}"] - "AAVS1": ["plasma membrane", "#FFD2FF", "{'raw': (505,2255), 'seg': (0,30), 'avgseg': (10,120)}"] - "ACTB": ["actin filaments", "#E6A0FF", "{'raw': (550,1300), 'seg': (0,18), 'avgseg': (0,35)}"] - "ACTN1": ["actin bundles", "#E696FF", "{'raw': (440,730), 'seg': (0,13), 'avgseg': (0,25)}"] - "MYH10": ["actomyosin bundles", "#FF82FF", "{'raw': (440,900), 'seg': (0,13), 'avgseg': (0,25)}"] - "PXN": ["matrix adhesions", "#CB1CCC", "{'raw': (410,490), 'seg': (0,5), 'avgseg': (0,5)}"] - -distribute: - # In case a (slurm) cluster is available - cores: 30 - number_of_workers: 16 - memory: "8GB" - queue: "aics_cpu_general" - walltime: "9-24:00:00" - python_env: "/home/matheus.viana/anaconda3/envs/cvapipe/" diff --git a/cvapipe_analysis/__init__.py b/cvapipe_analysis/__init__.py index d9fde33..40a96af 100644 --- a/cvapipe_analysis/__init__.py +++ b/cvapipe_analysis/__init__.py @@ -1,13 +1 @@ # -*- coding: utf-8 -*- - -"""Top-level package for cvapipe_analysis.""" - -__author__ = "Ritvik Vasan" -__email__ = "ritvik.vasan@alleninstitute.org" -# Do not edit this string manually, always use bumpversion -# Details in CONTRIBUTING.md -__version__ = "0.1.4" - - -def get_module_version(): - return __version__ diff --git a/cvapipe_analysis/bin/__init__.py b/cvapipe_analysis/bin/__init__.py index be2c45c..3ffd9a6 100644 --- a/cvapipe_analysis/bin/__init__.py +++ b/cvapipe_analysis/bin/__init__.py @@ -1,3 +1 @@ -# -*- coding: utf-8 -*- - -"""Bin scripts package for cvapipe_analysis.""" +# This is necessary here for packaging \ No newline at end of file diff --git a/cvapipe_analysis/bin/all.py b/cvapipe_analysis/bin/all.py deleted file mode 100644 index 4a5a542..0000000 --- a/cvapipe_analysis/bin/all.py +++ /dev/null @@ -1,119 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -""" -This script will run all tasks in a prefect Flow. - -When you add steps to you step workflow be sure to add them to the step list -and configure their IO in the `run` function. -""" - -import logging - -from distributed import LocalCluster -from prefect import Flow -from prefect.engine.executors import DaskExecutor, LocalExecutor -from cvapipe_analysis import steps - -############################################################################### - -log = logging.getLogger(__name__) - -############################################################################### - - -class All: - def __init__(self): - """ - Set all of your available steps here. - This is only used for data logging operations, not computation purposes. - """ - self.step_list = [steps.Raw()] - - def run( - self, - clean: bool = False, - debug: bool = False, - **kwargs, - ): - """ - Run a flow with your steps. - - Parameters - ---------- - clean: bool - Should the local staging directory be cleaned prior to this run. - Default: False (Do not clean) - debug: bool - A debug flag for the developer to use to manipulate how much data runs, - how it is processed, etc. - Default: False (Do not debug) - - Notes - ----- - Documentation on prefect: - https://docs.prefect.io/core/ - - Basic prefect example: - https://docs.prefect.io/core/ - """ - # Initalize steps - raw = steps.Raw() - - # Choose executor - if debug: - exe = LocalExecutor() - else: - # Set up connection to computation cluster - cluster = LocalCluster() - - # Inform of Dask UI - log.info(f"Cluster dashboard available at: {cluster.dashboard_link}") - - # Create dask executor - exe = DaskExecutor(cluster.scheduler_address) - - # Configure your flow - with Flow("cvapipe_analysis") as flow: - # If you want to clean the local staging directories pass clean - # If you want to utilize some debugging functionality pass debug - # If you don't utilize any of these, just pass the parameters you need. - raw( - clean=clean, - debug=debug, - **kwargs, # Allows us to pass `--n {some integer}` or other params - ) - - # Run flow and get ending state - state = flow.run(executor=exe) - - # Get and display any outputs you want to see on your local terminal - log.info(raw.get_result(state, flow)) - - def pull(self): - """ - Pull all steps. - """ - for step in self.step_list: - step.pull() - - def checkout(self): - """ - Checkout all steps. - """ - for step in self.step_list: - step.checkout() - - def push(self): - """ - Push all steps. - """ - for step in self.step_list: - step.push() - - def clean(self): - """ - Clean all steps. - """ - for step in self.step_list: - step.clean() diff --git a/cvapipe_analysis/bin/cli.py b/cvapipe_analysis/bin/cli.py deleted file mode 100644 index e6d1519..0000000 --- a/cvapipe_analysis/bin/cli.py +++ /dev/null @@ -1,35 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -""" -This script will convert all the steps into CLI callables. - -You should not edit this script. -""" - -import inspect -import logging - -import fire - -from cvapipe_analysis import steps -from cvapipe_analysis import tools -from cvapipe_analysis.bin.all import All - - -log = logging.getLogger() -logging.basicConfig( - level=logging.INFO, format="[%(levelname)4s:%(lineno)4s %(asctime)s] %(message)s" -) - -tools.general.create_workflow_file_from_config() -log.info("Workflow file created.") - -def cli(): - step_map = { - name.lower(): step - for name, step in inspect.getmembers(steps) - if inspect.isclass(step) - } - - fire.Fire({**step_map, "all": All}) diff --git a/cvapipe_analysis/constants.py b/cvapipe_analysis/constants.py deleted file mode 100644 index 73cc7ed..0000000 --- a/cvapipe_analysis/constants.py +++ /dev/null @@ -1,68 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - - -class DatasetFields: - CellId = "CellId" - CellIndex = "CellIndex" - CellLine = "CellLine" - CellLineId = "CellLineId" - CellLineName = "CellLineId/Name" - CellPopulationId = "CellPopulationId" - ChannelNumber405 = "ChannelNumber405" - ChannelNumber638 = "ChannelNumber638" - ChannelNumberBrightfield = "ChannelNumberBrightfield" - ChannelNumberStruct = "ChannelNumberStruct" - Clone = "Clone" - Col = "Col" - ColonyPosition = "ColonyPosition" - DataSetId = "DataSetId" - FOVId = "FOVId" - Gene = "Gene" - InstrumentId = "InstrumentId" - MembraneContourFileId = "MembraneContourFileId" - MembraneContourFilename = "MembraneContourFilename" - MembraneContourReadPath = "MembraneContourReadPath" - MembraneSegmentationFileId = "MembraneSegmentationFileId" - MembraneSegmentationFilename = "MembraneSegmentationFilename" - MembraneSegmentationReadPath = "MembraneSegmentationReadPath" - NucMembSegmentationAlgorithm = "NucMembSegmentationAlgorithm" - NucMembSegmentationAlgorithmVersion = "NucMembSegmentationAlgorithmVersion" - NucleusContourFileId = "NucleusContourFileId" - NucleusContourFilename = "NucleusContourFilename" - NucleusContourReadPath = "NucleusContourReadPath" - NucleusSegmentationFileId = "NucleusSegmentationFileId" - NucleusSegmentationFilename = "NucleusSegmentationFilename" - NucleusSegmentationReadPath = "NucleusSegmentationReadPath" - Objective = "Objective" - Passage = "Passage" - PixelScaleX = "PixelScaleX" - PixelScaleY = "PixelScaleY" - PixelScaleZ = "PixelScaleZ" - PlateId = "PlateId" - Protein = "Protein" - ProteinDisplayName = "ProteinDisplayName" - ProteinName = "ProteinId/Name" - Row = "Row" - RunId = "RunId" - SourceFileId = "SourceFileId" - SourceFilename = "SourceFilename" - SourceReadPath = "SourceReadPath" - StructEducationName = "StructEducationName" - Structure = "Structure" - StructureContourFileId = "StructureContourFileId" - StructureContourFilename = "StructureContourFilename" - StructureContourReadPath = "StructureContourReadPath" - StructureDisplayName = "StructureDisplayName" - StructureId = "StructureId" - StructureName = "StructureId/Name" - StructureSegmentationAlgorithm = "StructureSegmentationAlgorithm" - StructureSegmentationAlgorithmVersion = "StructureSegmentationAlgorithmVersion" - StructureSegmentationFileId = "StructureSegmentationFileId" - StructureSegmentationFilename = "StructureSegmentationFilename" - StructureSegmentationReadPath = "StructureSegmentationReadPath" - StructureShortName = "StructureShortName" - WellId = "WellId" - WellName = "WellName" - Workflow = "Workflow" - WorkflowId = "WorkflowId" diff --git a/cvapipe_analysis/exceptions.py b/cvapipe_analysis/exceptions.py deleted file mode 100644 index f4bdd56..0000000 --- a/cvapipe_analysis/exceptions.py +++ /dev/null @@ -1,21 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -from typing import List - -############################################################################### - - -class MissingDataError(Exception): - def __init__(self, missing_fields: List[str]): - # Run base exception init - super().__init__() - - # Store params for display - self.missing_fields = missing_fields - - def __str__(self): - return ( - f"Dataset provided does not have the required columns for this operation. " - f"Missing fields: {self.missing_fields}" - ) diff --git a/cvapipe_analysis/steps/__init__.py b/cvapipe_analysis/steps/__init__.py index 7d82ce8..40a96af 100644 --- a/cvapipe_analysis/steps/__init__.py +++ b/cvapipe_analysis/steps/__init__.py @@ -1,26 +1 @@ # -*- coding: utf-8 -*- - -from .load_data import LoadData -from .preprocessing import Preprocessing -from .compute_features import ComputeFeatures -from .shapemode import Shapemode -from .parameterization import Parameterization -from .aggregation import Aggregation -from .correlation import Correlation -from .stereotypy import Stereotypy -from .concordance import Concordance -from .cellpack import Cellpack - -__all__ = [ - "LoadData", - "Preprocessing", - "Shapemode", - "PcaPathCells", - "ComputeFeatures", - "Parameterization", - "Aggregation", - "Correlation", - "Stereotypy", - "Concordance", - "Cellpack" -] diff --git a/cvapipe_analysis/steps/aggregation/aggregation.py b/cvapipe_analysis/steps/aggregation/aggregation.py index cdf0bda..b523cce 100644 --- a/cvapipe_analysis/steps/aggregation/aggregation.py +++ b/cvapipe_analysis/steps/aggregation/aggregation.py @@ -5,9 +5,10 @@ from datastep import Step, log_run_params from typing import Dict, List, Optional, Union +import pandas as pd from tqdm import tqdm -from cvapipe_analysis.tools import io, general, cluster, shapespace from .aggregation_tools import Aggregator +from ...tools import io, general, cluster, shapespace log = logging.getLogger(__name__) @@ -20,13 +21,18 @@ def __init__( super().__init__(direct_upstream_tasks=direct_upstream_tasks, config=config) @log_run_params - def run(self, distribute: Optional[bool]=False, **kwargs): + def run( + self, + staging: Union[str, Path], + verbose: Optional[bool]=False, + distribute: Optional[bool]=False, + **kwargs): + + step_dir = Path(staging) / self.step_name - with general.configuration(self.step_local_staging_dir) as control: + with general.configuration(step_dir) as control: - for folder in ["repsagg", "aggmorph"]: - save_dir = self.step_local_staging_dir / folder - save_dir.mkdir(parents=True, exist_ok=True) + control.create_step_subdirs(step_dir, ["repsagg", "aggmorph"]) device = io.LocalStagingIO(control) df = device.load_step_manifest("preprocessing") @@ -35,7 +41,10 @@ def run(self, distribute: Optional[bool]=False, **kwargs): variables = control.get_variables_values_for_aggregation() df_agg = space.get_aggregated_df(variables, include_cellIds=True) df_sphere = space.get_cells_inside_ndsphere_of_radius() - df_agg = df_agg.append(df_sphere, ignore_index=True) + df_agg = pd.concat([df_agg, df_sphere]) + # Slurm can only handle arrays with max size 10K. Slurm will throw an + # error if df_agg is larger than that. + df_agg = df_agg.reset_index(drop=True) if distribute: @@ -47,12 +56,14 @@ def run(self, distribute: Optional[bool]=False, **kwargs): memory. To be investigated...''' distributor.set_chunk_size(1) distributor.distribute() - log.info(f"Multiple jobs have been launched. Please come back when the calculation is complete.") + distributor.jobs_warning() return None aggregator = Aggregator(control) - for index, row in tqdm(df_agg.iterrows(), total=len(df_agg)): + if verbose: + aggregator.set_verbose_mode_on() + for _, row in tqdm(df_agg.iterrows(), total=len(df_agg)): '''Concurrent processes inside. Do not use concurrent here.''' aggregator.execute(row) diff --git a/cvapipe_analysis/steps/aggregation/aggregation_tools.py b/cvapipe_analysis/steps/aggregation/aggregation_tools.py index f0bd446..1284088 100644 --- a/cvapipe_analysis/steps/aggregation/aggregation_tools.py +++ b/cvapipe_analysis/steps/aggregation/aggregation_tools.py @@ -29,26 +29,29 @@ def __init__(self, control): def workflow(self): self.set_agg_function() + self.print("Aggregating representations...") self.aggregate_parameterized_intensities() + self.print("Generating average morphed cells...") self.morph_on_shapemode_shape() def get_output_file_name(self): return f"{self.get_prefix_from_row(self.row)}.tif" def save(self): + # TODO: update aicsimageio and use TIF metadata for channel names n = len(self.CellIds) save_as = self.get_output_file_path() # Save morphed cell img = self.morphed - self.write_ome_tif(save_as, img, ['domain', save_as.stem], f"N{n}") + self.write_ome_tif(save_as, img, ["domain", self.row.alias], f"N{n}") # Save agg representation img = self.aggregated_parameterized_intensity save_as = Path(str(save_as).replace('aggmorph', 'repsagg')) - self.write_ome_tif(save_as, img, [save_as.stem], f"N{n}") + self.write_ome_tif(save_as, img, self.row.alias, f"N{n}") # Save norm agg representation img = self.aggregated_norm_parameterized_intensity save_as = Path(str(save_as).replace('.tif', '_norm.tif')) - self.write_ome_tif(save_as, img, [save_as.stem], f"N{n}") + self.write_ome_tif(save_as, img, self.row.alias, f"N{n}") return save_as def set_shape_space(self, space): @@ -57,17 +60,24 @@ def set_shape_space(self, space): def aggregate_parameterized_intensities(self): nc = self.control.get_ncores() - if not len(self.CellIds): + ncells = len(self.CellIds) + self.print(f"\t{ncells} cells found for {self.row.structure}") + if not ncells: raise ValueError("No cells found for parameterization.") + self.print(f"\tLoading PILRs...") with concurrent.futures.ProcessPoolExecutor(nc) as executor: pints = list(executor.map(self.read_parameterized_intensity, self.CellIds)) pints = np.array([p for p in pints if p is not None]) + self.print(f"\tAggregating...") pints_norm = self.normalize_representations(pints) agg_pint = self.agg_func(pints, axis=0) agg_pint_norm = self.agg_func(pints_norm, axis=0) + # Selecting the channel according to the alias of interest ch = self.control.get_aliases_to_parameterize().index(self.row.alias) - self.aggregated_parameterized_intensity = agg_pint#[ch].copy() - self.aggregated_norm_parameterized_intensity = agg_pint_norm#[ch].copy() + agg_pint = np.expand_dims(agg_pint[ch], 0) + agg_pint_norm = np.expand_dims(agg_pint_norm[ch], 0) + self.aggregated_parameterized_intensity = agg_pint + self.aggregated_norm_parameterized_intensity = agg_pint_norm return def set_agg_function(self): @@ -101,7 +111,9 @@ def voxelize_and_parameterize_shapemode_shape(self): return def morph_on_shapemode_shape(self): + self.print("\tVoxelizing shape mode...") self.voxelize_and_parameterize_shapemode_shape() + self.print("\tMorphing...") self.morphed = cytoparam.morph_representation_on_shape( img=self.domain, param_img_coords=self.coords_param, @@ -112,13 +124,14 @@ def morph_on_shapemode_shape(self): if __name__ == "__main__": - config = general.load_config_file() - control = controller.Controller(config) - - parser = argparse.ArgumentParser(description='Batch aggregation.') - parser.add_argument('--csv', help='Path to the dataframe.', required=True) + parser = argparse.ArgumentParser(description="Batch single cell feature extraction.") + parser.add_argument("--staging", help="Path to staging.", required=True) + parser.add_argument("--csv", help="Path to the dataframe.", required=True) args = vars(parser.parse_args()) + config = general.load_config_file(args["staging"]) + control = controller.Controller(config) + df = pd.read_csv(args['csv'], index_col=0) aggregator = Aggregator(control) diff --git a/cvapipe_analysis/steps/cellpack/cellpack.py b/cvapipe_analysis/steps/cellpack/cellpack.py index 8a0adb1..548a435 100644 --- a/cvapipe_analysis/steps/cellpack/cellpack.py +++ b/cvapipe_analysis/steps/cellpack/cellpack.py @@ -16,8 +16,8 @@ from datastep import Step, log_run_params from aicsimageio import AICSImage, writers -from cvapipe_analysis.tools import general, cluster, shapespace from .cellpack_tools import ObjectCollector +from ...tools import general, cluster, shapespace tr = pdb.set_trace log = logging.getLogger(__name__) diff --git a/cvapipe_analysis/steps/compute_features/compute_features.py b/cvapipe_analysis/steps/compute_features/compute_features.py index ead2058..0a5714f 100644 --- a/cvapipe_analysis/steps/compute_features/compute_features.py +++ b/cvapipe_analysis/steps/compute_features/compute_features.py @@ -7,7 +7,7 @@ from typing import Dict, List, Optional, Union import concurrent -from cvapipe_analysis.tools import io, general, cluster +from ...tools import io, general, cluster from .compute_features_tools import FeatureCalculator log = logging.getLogger(__name__) @@ -21,27 +21,41 @@ def __init__( super().__init__(direct_upstream_tasks=direct_upstream_tasks, config=config) @log_run_params - def run(self, distribute: Optional[bool]=False, **kwargs): + def run( + self, + staging: Union[str, Path], + debug: Optional[bool]=False, + verbose: Optional[bool]=False, + distribute: Optional[bool]=False, + **kwargs): + + step_dir = Path(staging) / self.step_name - with general.configuration(self.step_local_staging_dir) as control: + with general.configuration(step_dir) as control: + + control.create_step_subdirs(step_dir, ["cell_features"]) device = io.LocalStagingIO(control) df = device.load_step_manifest("loaddata") log.info(f"Manifest: {df.shape}") - save_dir = self.step_local_staging_dir/"cell_features" - save_dir.mkdir(parents=True, exist_ok=True) - if distribute: distributor = cluster.FeaturesDistributor(self, control) distributor.set_data(df) distributor.distribute() - log.info(f"Multiple jobs have been launched. Please come back when the calculation is complete.") + distributor.jobs_warning() return None calculator = FeatureCalculator(control) + if verbose: + calculator.set_verbose_mode_on() + if debug: + for index, row in df.iterrows(): + calculator.set_row(row) + calculator.workflow() + return with concurrent.futures.ProcessPoolExecutor(control.get_ncores()) as executor: executor.map(calculator.execute, [row for _,row in df.iterrows()]) @@ -57,8 +71,7 @@ def run(self, distribute: Optional[bool]=False, **kwargs): log.info(f"Total of {len(df_miss)} indices.") log.info(f"Saving manifest...") - self.manifest = df.merge(df_results, left_index=True, right_index=True, how="outer") - manifest_path = self.step_local_staging_dir / 'manifest.csv' - self.manifest.to_csv(manifest_path) + df = df.merge(df_results, left_index=True, right_index=True, how="outer") + df.to_csv(step_dir/"manifest.csv") return diff --git a/cvapipe_analysis/steps/compute_features/compute_features_tools.py b/cvapipe_analysis/steps/compute_features/compute_features_tools.py index 78e80d4..191615c 100644 --- a/cvapipe_analysis/steps/compute_features/compute_features_tools.py +++ b/cvapipe_analysis/steps/compute_features/compute_features_tools.py @@ -24,9 +24,13 @@ def __init__(self, control): self.subfolder = "computefeatures/cell_features" def workflow(self): + self.print(f"Loading images of cell {self.row.name}...") self.load_single_cell_data() + self.print("Aligning data...") self.align_data() + self.print("Computing features...") self.compute_all_features() + self.print("Done.") return def get_output_file_name(self): @@ -42,6 +46,7 @@ def save(self): def compute_all_features(self): features = {} for alias in self.control.get_aliases_for_feature_extraction(): + self.print(f"\tRunning alias {alias}.") fs = self.compute_features_for_alias(alias) fs = dict((f"{alias}_{k}", v) for k, v in fs.items()) features.update(fs) @@ -53,6 +58,7 @@ def compute_features_for_alias(self, alias): chId = self.channels.index(channel) # RAW if self.control.should_calculate_intensity_features(alias): + self.print("\t\tIntensity features...") mask_alias = self.control.get_mask_alias(alias) mask_channel = self.control.get_channel_from_alias(mask_alias) mask_chId = self.channels.index(mask_channel) @@ -62,8 +68,10 @@ def compute_features_for_alias(self, alias): ) # SEG else: + self.print("\t\tBasic features...") features = self.get_basic_features(self.data_aligned[chId]) if self.control.should_calculate_shcoeffs(alias): + self.print("\t\tSHE...") coeffs = self.get_coeff_features(self.data_aligned[chId], alias) features.update(coeffs) return features @@ -161,13 +169,14 @@ def get_surface_area(input_img): if __name__ == "__main__": - config = general.load_config_file() - control = controller.Controller(config) - parser = argparse.ArgumentParser(description="Batch single cell feature extraction.") + parser.add_argument("--staging", help="Path to staging.", required=True) parser.add_argument("--csv", help="Path to the dataframe.", required=True) args = vars(parser.parse_args()) + config = general.load_config_file(args["staging"]) + control = controller.Controller(config) + df = pd.read_csv(args["csv"], index_col="CellId") print(f"Processing dataframe of shape {df.shape}") diff --git a/cvapipe_analysis/steps/concordance/concordance.py b/cvapipe_analysis/steps/concordance/concordance.py index c1fc1cf..b3df607 100644 --- a/cvapipe_analysis/steps/concordance/concordance.py +++ b/cvapipe_analysis/steps/concordance/concordance.py @@ -7,7 +7,7 @@ import concurrent from tqdm import tqdm -from cvapipe_analysis.tools import io, general, cluster, shapespace, plotting +from ...tools import io, general, cluster, shapespace, plotting from .concordance_tools import ConcordanceCalculator log = logging.getLogger(__name__) @@ -22,13 +22,18 @@ def __init__( super().__init__(direct_upstream_tasks=direct_upstream_tasks, config=config) @log_run_params - def run(self, distribute: Optional[bool] = False, **kwargs): + def run( + self, + staging: Union[str, Path], + verbose: Optional[bool]=False, + distribute: Optional[bool]=False, + **kwargs): + + step_dir = Path(staging) / self.step_name - with general.configuration(self.step_local_staging_dir) as control: + with general.configuration(step_dir) as control: - for folder in ['values', 'plots']: - save_dir = self.step_local_staging_dir / folder - save_dir.mkdir(parents=True, exist_ok=True) + control.create_step_subdirs(step_dir, ["values", "plots"]) device = io.LocalStagingIO(control) df = device.load_step_manifest("preprocessing") @@ -49,9 +54,8 @@ def run(self, distribute: Optional[bool] = False, **kwargs): distributor = cluster.ConcordanceDistributor(self, control) distributor.set_data(df_agg) distributor.distribute() - log.info( - f"Multiple jobs have been launched. Please come back when the calculation is complete.") - + distributor.jobs_warning() + return None calculator = ConcordanceCalculator(control) diff --git a/cvapipe_analysis/steps/concordance/concordance_tools.py b/cvapipe_analysis/steps/concordance/concordance_tools.py index 1fa1a20..70b52a5 100644 --- a/cvapipe_analysis/steps/concordance/concordance_tools.py +++ b/cvapipe_analysis/steps/concordance/concordance_tools.py @@ -42,13 +42,14 @@ def save(self): if __name__ == "__main__": - config = general.load_config_file() - control = controller.Controller(config) - - parser = argparse.ArgumentParser(description='Batch concordance calculation.') - parser.add_argument('--csv', help='Path to the dataframe.', required=True) + parser = argparse.ArgumentParser(description="Batch single cell feature extraction.") + parser.add_argument("--staging", help="Path to staging.", required=True) + parser.add_argument("--csv", help="Path to the dataframe.", required=True) args = vars(parser.parse_args()) + config = general.load_config_file(args["staging"]) + control = controller.Controller(config) + df = pd.read_csv(args['csv'], index_col=0) calculator = ConcordanceCalculator(control) diff --git a/cvapipe_analysis/steps/correlation/correlation.py b/cvapipe_analysis/steps/correlation/correlation.py index bf9c535..c34a991 100644 --- a/cvapipe_analysis/steps/correlation/correlation.py +++ b/cvapipe_analysis/steps/correlation/correlation.py @@ -1,13 +1,14 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- import logging +import pandas as pd from pathlib import Path from typing import Dict, List, Optional, Union from datastep import Step, log_run_params from tqdm import tqdm -from cvapipe_analysis.tools import io, general, cluster, shapespace +from ...tools import io, general, cluster, shapespace from .correlation_tools import CorrelationCalculator log = logging.getLogger(__name__) @@ -23,31 +24,48 @@ def __init__( @log_run_params def run( self, - distribute: Optional[bool] = False, - **kwargs - ): + staging: Union[str, Path], + debug: Optional[bool]=False, + aliases="all", + verbose: Optional[bool]=False, + distribute: Optional[bool]=False, + **kwargs): + + step_dir = Path(staging) / self.step_name - with general.configuration(self.step_local_staging_dir) as control: + with general.configuration(step_dir) as control: - for folder in ['values']: - save_dir = self.step_local_staging_dir / folder - save_dir.mkdir(parents=True, exist_ok=True) + control.create_step_subdirs(step_dir, ["values"]) device = io.LocalStagingIO(control) df = device.load_step_manifest("preprocessing") space = shapespace.ShapeSpace(control) if control.get_number_of_map_points() == 1: # Do not remove extreme points when working on - # matched datasets for whcih the number of bins + # matched datasets for which the number of bins # equals 1 (consistency with previous analysis). space.set_remove_extreme_points(False) space.execute(df) variables = control.get_variables_values_for_aggregation() df_agg = space.get_aggregated_df(variables, include_cellIds=True) - df_agg = space.sample_cell_ids(df_agg, 1000) df_sphere = space.get_cells_inside_ndsphere_of_radius() - df_agg = df_agg.append(df_sphere, ignore_index=True) + df_agg = pd.concat([df_agg, df_sphere]) + + # df_agg = pd.read_csv("/allen/aics/assay-dev/MicroscopyOtherData/Viana/projects/trash/df_agg.csv", index_col=0) + # for index, row in df_agg.iterrows(): + # df_agg.at[index, "CellIds"] = row.CellIds.replace("\']","").replace("[\'","").split("\', \'") + # df_agg = df_agg.loc[df_agg.mpId==1] # test large number of cells + + if aliases != "all": + if verbose: + print(f"Initial shape of aggregation table: {df_agg.shape}") + if not isinstance(aliases, list): + aliases = [aliases] + df_agg = df_agg.loc[df_agg.alias.isin(aliases)] + if verbose: + print(f"Final shape of aggregation table: {df_agg.shape}") + df_agg = df_agg.reset_index(drop=True) agg_cols = [f for f in df_agg.columns if f not in ["CellIds", "structure"]] df_agg = df_agg.groupby(agg_cols).agg({"CellIds": sum}) df_agg = df_agg.reset_index() @@ -57,11 +75,12 @@ def run( distributor = cluster.CorrelationDistributor(self, control) distributor.set_data(df_agg) distributor.distribute_by_row() - log.info( - f"Multiple jobs have been launched. Please come back when the calculation is complete.") + distributor.jobs_warning() return None calculator = CorrelationCalculator(control) + if verbose: + calculator.set_verbose_mode_on() for _, row in tqdm(df_agg.iterrows(), total=len(df_agg)): '''Concurrent processes inside. Do not use concurrent here.''' calculator.execute(row) diff --git a/cvapipe_analysis/steps/correlation/correlation_tools.py b/cvapipe_analysis/steps/correlation/correlation_tools.py index 39061d8..bd43a43 100644 --- a/cvapipe_analysis/steps/correlation/correlation_tools.py +++ b/cvapipe_analysis/steps/correlation/correlation_tools.py @@ -23,32 +23,11 @@ class CorrelationCalculator(io.DataProducer): correlations on binary representations only. """ - rep_length = 532610 # Need some work to make general - def __init__(self, control): super().__init__(control) self.ncores = control.get_ncores() self.subfolder = 'correlation/values' - - def read_representation_as_boolean(self, eindex): - i, index = eindex - rep = self.read_parameterized_intensity(index).astype(bool).flatten() - self.reps[i] = rep - return - - def load_representations(self): - self.ncells = len(self.row.CellIds) - self.reps = np.zeros((self.ncells, self.rep_length), dtype=bool) - repsize = int(sys.getsizeof(self.reps)) / float(1 << 20) - print(f"Representations shape: {self.reps.shape} ({self.reps.dtype}, {repsize:.1f}Mb)") - - _ = Parallel(n_jobs=self.ncores, backend="threading")( - delayed(self.read_representation_as_boolean)(eindex) - for eindex in tqdm(enumerate(self.row.CellIds), total=self.ncells) - ) - - def correlate_all(self): - self.corrs = np.corrcoef(self.reps, dtype=np.float32) + self.pilr_size = control.get_parameterized_representation_size() # 532610 in the paper def workflow(self): self.load_representations() @@ -56,24 +35,51 @@ def workflow(self): return def get_output_file_name(self): - fname = self.get_prefix_from_row(self.row) + ''' + This function has to return a file name with extension + so that the resulting string can be used as output + verification. If class writes multiple files, then the + file extension have to be manually altered. + ''' + fname = f"{self.get_prefix_from_row(self.row)}.tif" return fname def save(self): save_as = self.get_output_file_path() - skio.imsave(f"{save_as}.tif", self.corrs) - pd.DataFrame({"CellIds": self.row.CellIds}).to_csv(f"{save_as}.csv") + skio.imsave(save_as, self.corrs) + pd.DataFrame({"CellIds": self.row.CellIds}).to_csv(str(save_as).replace(".tif",".csv")) return f"{save_as}.tif" -if __name__ == "__main__": + def read_pilr(self, eCellId): + i, CellId = eCellId + pilr, names = self.read_parameterized_intensity(CellId, return_intensity_names=True) + self.pilrs[i] = pilr[names.index(self.row.alias)].flatten() + return - config = general.load_config_file() - control = controller.Controller(config) + def load_representations(self): + self.ncells = len(self.row.CellIds) + self.pilrs = np.zeros((self.ncells, self.pilr_size), dtype=np.float32) + self.control.display_array_size_in_mb(self.pilrs, self.print) + + _ = Parallel(n_jobs=self.ncores, backend="threading")( + delayed(self.read_pilr)(eindex) + for eindex in tqdm(enumerate(self.row.CellIds), total=self.ncells) + ) + return + + def correlate_all(self): + self.corrs = np.corrcoef(self.pilrs, dtype=np.float32) - parser = argparse.ArgumentParser(description='Batch correlation calculation.') - parser.add_argument('--csv', help='Path to the dataframe.', required=True) +if __name__ == "__main__": + + parser = argparse.ArgumentParser(description="Batch single cell feature extraction.") + parser.add_argument("--staging", help="Path to staging.", required=True) + parser.add_argument("--csv", help="Path to the dataframe.", required=True) args = vars(parser.parse_args()) + config = general.load_config_file(args["staging"]) + control = controller.Controller(config) + df = pd.read_csv(args['csv'], index_col=0) df = df.T df.CellIds = df.CellIds.astype(object) diff --git a/cvapipe_analysis/steps/load_data/load_data.py b/cvapipe_analysis/steps/load_data/load_data.py index d4959d7..74f59cd 100644 --- a/cvapipe_analysis/steps/load_data/load_data.py +++ b/cvapipe_analysis/steps/load_data/load_data.py @@ -2,11 +2,11 @@ # -*- coding: utf-8 -*- import logging from pathlib import Path -from typing import Dict, List, Optional, Union from datastep import Step, log_run_params +from typing import Dict, List, Optional, Union -from cvapipe_analysis.tools import general from .load_data_tools import DataLoader +from ...tools import general, controller log = logging.getLogger(__name__) @@ -19,15 +19,24 @@ def __init__( super().__init__(direct_upstream_tasks=direct_upstream_tasks, config=config) @log_run_params - def run(self, **kwargs): - - with general.configuration(self.step_local_staging_dir) as control: - - loader = DataLoader(control) - df = loader.load(kwargs) - - self.manifest = df - manifest_path = self.step_local_staging_dir / 'manifest.csv' - self.manifest.to_csv(manifest_path) - - return manifest_path \ No newline at end of file + def run( + self, + staging, + ignore_raw_data = False, + **kwargs + ): + + path = general.get_path_to_default_config() + config = general.load_config_file(path) + config["project"]["local_staging"] = staging + control = controller.Controller(config) + + loader = DataLoader(control) + if ignore_raw_data: + loader.disable_download_of_raw_data() + df = loader.load(kwargs) + + path = Path(staging) + df.to_csv(path/f"{self.step_name}/manifest.csv") + general.save_config(config, path) + return diff --git a/cvapipe_analysis/steps/load_data/load_data_tools.py b/cvapipe_analysis/steps/load_data/load_data_tools.py index 65bb728..0b6be15 100644 --- a/cvapipe_analysis/steps/load_data/load_data_tools.py +++ b/cvapipe_analysis/steps/load_data/load_data_tools.py @@ -6,7 +6,7 @@ from tqdm import tqdm from pathlib import Path -from cvapipe_analysis.tools import io +from ...tools import io, general class DataLoader(io.LocalStagingIO): """ @@ -37,36 +37,46 @@ class DataLoader(io.LocalStagingIO): 'crop_seg', 'crop_raw' ] + download_raw_data = True def __init__(self, control): super().__init__(control) self.subfolder = 'loaddata' + def disable_download_of_raw_data(self): + self.download_raw_data = False + def load(self, parameters): if any(p in parameters for p in ["csv", "fmsid"]): df = self.download_local_data(parameters) else: df = self.download_quilt_data(parameters) df = self.drop_aliases_related_columns(df) + return df def drop_aliases_related_columns(self, df): return df[[f for f in df.columns if not any(w in f for w in self.control.get_data_aliases())]] def download_quilt_data(self, parameters): - pkg_name = "default" - if "dataset" in parameters: - pkg_name = parameters["dataset"] - self.pkg = quilt3.Package.browse(self.packages[pkg_name], self.registry) - self.pkg["metadata.csv"].fetch(self.control.get_staging()/"manifest.csv") - df_meta = pd.read_csv(self.control.get_staging()/"manifest.csv", index_col="CellId") - + + print("Creating data folders...") seg_folder = self.control.get_staging()/f"{self.subfolder}/crop_seg" seg_folder.mkdir(parents=True, exist_ok=True) raw_folder = self.control.get_staging()/f"{self.subfolder}/crop_raw" raw_folder.mkdir(parents=True, exist_ok=True) + pkg_name = "default" + if "dataset" in parameters: + pkg_name = parameters["dataset"] + if pkg_name not in self.packages: + raise ValueError(f"Package {pkg_name} not found. Packages available: {[k for k in self.packages.keys()]}.") + self.pkg = quilt3.Package.browse(self.packages[pkg_name], self.registry) + self.pkg["metadata.csv"].fetch(self.control.get_staging()/"manifest.csv") + print("Reading manifest...") + df_meta = pd.read_csv(self.control.get_staging()/"manifest.csv", index_col="CellId", low_memory=False) + if "test" in parameters: ncells = 12 if "ncells" in parameters: @@ -74,26 +84,34 @@ def download_quilt_data(self, parameters): print(f"Downloading test subset of {pkg_name} dataset.") df_meta = self.get_interphase_test_set(df_meta, n=ncells) for i, row in tqdm(df_meta.iterrows(), total=len(df_meta)): - self.pkg[row["crop_raw"]].fetch(self.control.get_staging()/f"loaddata/{row.crop_raw}") self.pkg[row["crop_seg"]].fetch(self.control.get_staging()/f"loaddata/{row.crop_seg}") + if self.download_raw_data: + self.pkg[row["crop_raw"]].fetch(self.control.get_staging()/f"loaddata/{row.crop_raw}") else: + if self.download_raw_data: + print("Downloading single cell raw images...") + self.pkg["crop_raw"].fetch(raw_folder) + print("Downloading single cell segmentations...") self.pkg["crop_seg"].fetch(seg_folder) - self.pkg["crop_raw"].fetch(raw_folder) - # Append full path to file paths + print("Appending full path to file paths...") for index, row in tqdm(df_meta.iterrows(), total=len(df_meta)): df_meta.at[index, "crop_seg"] = str(self.control.get_staging()/f"loaddata/{row.crop_seg}") - df_meta.at[index, "crop_raw"] = str(self.control.get_staging()/f"loaddata/{row.crop_raw}") + if self.download_raw_data: + df_meta.at[index, "crop_raw"] = str(self.control.get_staging()/f"loaddata/{row.crop_raw}") + + if not self.download_raw_data: + df_meta = df_meta.drop(columns=["crop_raw"]) return df_meta def download_local_data(self, parameters): - use_fms = use_fms="fmsid" in parameters + use_fms = "fmsid" in parameters df = self.load_data_from_csv(parameters, use_fms) - self.is_dataframe_valid(df) + #self.is_dataframe_valid(df) df = df.set_index('CellId', drop=True) - if not use_fms: - self.create_symlinks(df) + # if not use_fms: + # self.create_symlinks(df) return df def is_dataframe_valid(self, df): diff --git a/cvapipe_analysis/steps/multi_res_struct_compare/__init__.py b/cvapipe_analysis/steps/multi_res_struct_compare/__init__.py deleted file mode 100644 index dd50a3d..0000000 --- a/cvapipe_analysis/steps/multi_res_struct_compare/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -# -*- coding: utf-8 -*- - -from .multi_res_struct_compare import MultiResStructCompare # noqa: F401 - -__all__ = ["MultiResStructCompare"] diff --git a/cvapipe_analysis/steps/multi_res_struct_compare/constants.py b/cvapipe_analysis/steps/multi_res_struct_compare/constants.py deleted file mode 100644 index d6b9d60..0000000 --- a/cvapipe_analysis/steps/multi_res_struct_compare/constants.py +++ /dev/null @@ -1,97 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - - -class DatasetFieldsMorphed: - CellId1 = "CellId_1" - CellId2 = "CellId_2" - StructureName1 = "structure_name_1" - StructureName2 = "structure_name_2" - Bin1 = "bin_1" - Bin2 = "bin_2" - SourceReadPath1 = "path_raw_morph_1" # path_raw_morph_1 - SourceReadPath2 = "path_raw_morph_2" # path_raw_morph_2 - - -class DatasetFieldsIC: - CellId = "CellId" - CellIndex = "CellIndex" - FOVId = "FOVId" - StructureName1 = "GeneratedStructureName_i" - StructureName2 = "GeneratedStructureName_j" - GeneratedStructureInstance_i = "GeneratedStructureInstance_i" - GeneratedStructureInstance_j = "GeneratedStructureInstance_j" - SourceReadPath1 = "GeneratedStructuePath_i" - SourceReadPath2 = "GeneratedStructuePath_j" - SaveDir = "save_dir" - SaveRegPath = "save_reg_path" - - -class DatasetFieldsAverageMorphed: - NumStructs = 26 - NumBins = 9 - StructureIndex1 = "ChannelIndex_i" - StructureIndex2 = "ChannelIndex_j" - StructureName1 = "ChannelGeneName_i" - StructureName2 = "ChannelGeneName_j" - PC_bin = "PC_bin" - - -class StructureGenes: - # This is the order that data is stored in the 5d stack - CENT2 = "CENT2" - TUBA1B = "TUBA1B" - PXN = "PXN" - TJP1 = "TJP1" - LMNB1 = "LMNB1" - NUP153 = "NUP153" - ST6GAL1 = "ST6GAL1" - LAMP1 = "LAMP1" - ACTB = "ACTB" - DSP = "DSP" - FBL = "FBL" - NPM1 = "NPM1" - TOMM20 = "TOMM20" - PMP34 = "PMP34" - ACTN1 = "ACTN1" - GJA1 = "GJA1" - H2B = "H2B" - SON = "SON" - SEC61B = "SEC61B" - RAB5A = "RAB5A" - MYH10 = "MYH10" - AAVS1 = "AAVS1" - CTNNB1 = "CTNNB1" - ATP2A2 = "ATP2A2" - SMC1A = "SMC1A" - CELL_NUC = "CELL+NUCLEUS" - - -class StructureGeneFullNames: - # This is the order that data is stored in the 5d stack - CENT2 = "Centrioles" - TUBA1B = "Microtubules" - PXN = "Matrix adhesions" - TJP1 = "Tight junctions" - LMNB1 = "Nuclear envelope" - NUP153 = "Nuclear pores" - Golgi = "Golgi" - LAMP1 = "Lysosome" - ACTB = "Filamentous actin" - DSP = "Desmosomes" - FBL = "Nucleolus (Dense Fibrillar Component)" - NPM1 = "Nucleolus (Granular Component)" - TOMM20 = "Mitochondria" - PMP34 = "PMP34" - ACTN1 = "Peroxisomes" - GJA1 = "Gap junctions" - H2B = "Histone" - SON = "Nuclear Speckles" - SEC61B = "Endoplasmic Reticulum" - RAB5A = "Endosomes" - MYH10 = "Actomyosin bundles" - AAVS1 = "Plasma membrane" - CTNNB1 = "Adherens junctions" - ATP2A2 = "Sarcoplasmic reticulum" - SMC1A = "Cohesin" - CELL_NUC = "CELL+NUCLEUS" diff --git a/cvapipe_analysis/steps/multi_res_struct_compare/exceptions.py b/cvapipe_analysis/steps/multi_res_struct_compare/exceptions.py deleted file mode 100644 index fbb63c1..0000000 --- a/cvapipe_analysis/steps/multi_res_struct_compare/exceptions.py +++ /dev/null @@ -1,43 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -from typing import List, Union, Optional -from pathlib import Path - -import dask.dataframe as dd -import pandas as pd - - -class MissingDataError(Exception): - def __init__( - self, dataset: Union[pd.DataFrame, dd.DataFrame], missing_fields: List[str] - ): - # Run base exception init - super().__init__() - - # Store params for display - self.dataset = dataset - self.missing_fields = missing_fields - - def __str__(self): - return ( - f"Dataset provided does not have the required columns for this operation. " - f"Missing fields: {self.missing_fields} " - ) - - -def check_required_fields( - dataset: Union[str, Path, pd.DataFrame, dd.DataFrame], - required_fields: List[str], -) -> Optional[MissingDataError]: - # Handle dataset provided as string or path - if isinstance(dataset, (str, Path)): - dataset = Path(dataset).expanduser().resolve(strict=True) - - # Read dataset - dataset = dd.read_csv(dataset) - - # Check that all columns provided as required are in the dataset - missing_fields = set(required_fields) - set(dataset.columns) - if len(missing_fields) > 0: - raise MissingDataError(dataset, missing_fields) diff --git a/cvapipe_analysis/steps/multi_res_struct_compare/multi_res_struct_compare.py b/cvapipe_analysis/steps/multi_res_struct_compare/multi_res_struct_compare.py deleted file mode 100644 index a23a24c..0000000 --- a/cvapipe_analysis/steps/multi_res_struct_compare/multi_res_struct_compare.py +++ /dev/null @@ -1,232 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -import logging -from pathlib import Path -from typing import Dict, List, Optional, Union - -import pandas as pd - -from aics_dask_utils import DistributedHandler -from aicsimageio import AICSImage - -from datastep import Step, log_run_params - -from .utils import ( - compute_distance_metric, - clean_up_results, - make_plot, - make_5d_stack_cross_corr_dataframe, -) - -from .constants import ( - DatasetFieldsMorphed, - DatasetFieldsIC, - DatasetFieldsAverageMorphed, -) - -from .exceptions import check_required_fields - -############################################################################### - -log = logging.getLogger(__name__) - -############################################################################### - -REQUIRED_DATASET_FIELDS_MORPHED = [ - DatasetFieldsMorphed.StructureName1, - DatasetFieldsMorphed.StructureName2, - DatasetFieldsMorphed.SourceReadPath1, - DatasetFieldsMorphed.SourceReadPath2, - DatasetFieldsMorphed.Bin1, - DatasetFieldsMorphed.Bin2, - DatasetFieldsMorphed.CellId1, - DatasetFieldsMorphed.CellId2, -] - -REQUIRED_DATASET_FIELDS_IC = [ - DatasetFieldsIC.StructureName1, - DatasetFieldsIC.StructureName2, - DatasetFieldsIC.SourceReadPath1, - DatasetFieldsIC.SourceReadPath2, - DatasetFieldsIC.CellId, - DatasetFieldsIC.SaveDir, - DatasetFieldsIC.SaveRegPath, -] - - -class MultiResStructCompare(Step): - def __init__( - self, - direct_upstream_tasks: List["Step"] = [], - config: Optional[Union[str, Path, Dict[str, str]]] = None, - ): - super().__init__(direct_upstream_tasks=direct_upstream_tasks, config=config) - - @log_run_params - def run( - self, - px_size=0.29, - image_dims_crop_size=(64, 160, 96), - input_csv_loc: Optional[str] = None, - input_5d_stack: Optional[str] = None, - max_rows: Optional[int] = None, - permuted: Optional[bool] = None, - distributed_executor_address: Optional[str] = None, - batch_size: Optional[int] = None, - **kwargs, - ): - """ - Parameters - ---------- - px_size: float - How big are the (cubic) input pixels in micrometers - Default: 0.29 (For IC cells) - For morphed cells: 0.108 - - image_dims_crop_size: Tuple[int] - How to crop the input images before the resizing pyamid begins - This is only for IC cells - - input_csv_loc: Optional[str] - Path to input csv, can be a path to IC cells or morphed cells - - For IC cells, pass in the results of the generate_gfp_instantiations step - Example: - "/allen/aics/modeling/ritvik/projects/cvapipe/local_staging/ - /generategfpinstantiations/images_CellID_86655/manifest.csv" - - For morphed cells, pass in a csv containing paths to Matheus' - morphed cells for a particular PC - Example: - "/allen/aics/modeling/ritvik/projects/cvapipe/ - FinalMorphedStereotypyDatasetPC1_9bins.csv" - - Note: Cannot provide this csv path along with 5d stack - - input_5d_stack: Optional[str] - Path to the average morphed cell, this is a .tif - Example: - "/allen/aics/assay-dev/MicroscopyOtherData/Viana/projects/ - assay-dev-cytoparam/avgcell/DNA_MEM_PC1_seg_avg.tif" - - Note: cannot provide this 5d stack along with a csv path - - permuted: Optional[bool] - If True, compute permuted correlations at multi resolutions - Default: None - - Returns - ------- - result: pathlib.Path - Path to manifest - """ - - # Adding hidden attributes to use in compute distance metric function - self._input_csv_loc = input_csv_loc - self._input_5d_stack = input_5d_stack - Input_5d_Stack = None - self._px_size = px_size - - # Make sure that both 5d stack and input csv are not provided at same time - assert not all([self._input_csv_loc, self._input_5d_stack]) - - # Handle dataset provided as string or path - if isinstance(self._input_csv_loc, (str, Path)): - dataset = Path(self._input_csv_loc).expanduser().resolve(strict=True) - - dataset = pd.read_csv(dataset) - - # Flag dataset as morphed cells - if set(dataset.columns).intersection(set(REQUIRED_DATASET_FIELDS_IC)): - REQUIRED_DATASET_FIELDS = REQUIRED_DATASET_FIELDS_IC - # Check dataset and manifest have required fields - check_required_fields( - dataset=dataset, - required_fields=REQUIRED_DATASET_FIELDS_IC, - ) - - # Flad dataset as IC cells - if set(dataset.columns).intersection(set(REQUIRED_DATASET_FIELDS_MORPHED)): - REQUIRED_DATASET_FIELDS = REQUIRED_DATASET_FIELDS_MORPHED - # Check dataset and manifest have required fields - check_required_fields( - dataset=dataset, - required_fields=REQUIRED_DATASET_FIELDS_MORPHED, - ) - - # Subset down - dataset = dataset[REQUIRED_DATASET_FIELDS] - - # Handle dataset provided as string or path - if isinstance(self._input_5d_stack, (str, Path)): - Input_5d_Stack = ( - Path(self._input_5d_stack).expanduser().resolve(strict=True) - ) - - Input_5d_Stack = AICSImage(Input_5d_Stack).data - - assert Input_5d_Stack.shape[1] == DatasetFieldsAverageMorphed.NumStructs - assert Input_5d_Stack.shape[3] == DatasetFieldsAverageMorphed.NumBins - - dataset = make_5d_stack_cross_corr_dataframe( - DatasetFieldsAverageMorphed.NumStructs, - DatasetFieldsAverageMorphed.NumBins, - ) - - if max_rows: - dataset = dataset.head(max_rows) - - # Empty futures list - distance_metric_futures = [] - distance_metric_results = [] - - # Process each row - with DistributedHandler(distributed_executor_address) as handler: - # Start processing - distance_metric_future = handler.client.map( - compute_distance_metric, - [row for i, row in dataset.iterrows()], - [Input_5d_Stack for i in range(len(dataset))], - [permuted for i in range(len(dataset))], - [px_size for i in range(len(dataset))], - [image_dims_crop_size for i in range(len(dataset))], - ) - - distance_metric_futures.append(distance_metric_future) - result = handler.gather(distance_metric_future) - distance_metric_results.append(result) - - # Assemble final dataframe - df_final = clean_up_results(distance_metric_results, permuted) - - # make a manifest - self.manifest = pd.DataFrame(columns=["Description", "path"]) - - # where to save outputs - pairwise_dir = self.step_local_staging_dir / "pairwise_metrics" - pairwise_dir.mkdir(parents=True, exist_ok=True) - pairwise_loc = pairwise_dir / "multires_pairwise_similarity.csv" - plot_dir = self.step_local_staging_dir / "pairwise_plots" - plot_dir.mkdir(parents=True, exist_ok=True) - plot_loc = plot_dir / "multi_resolution_image_correlation.png" - - # save pairwise dataframe to csv - df_final.to_csv(pairwise_loc, index=False) - self.manifest = self.manifest.append( - {"Description": "raw similarity scores", "path": pairwise_loc}, - ignore_index=True, - ) - - # make a plot - make_plot(data=df_final, plot_dir=plot_dir) - self.manifest = self.manifest.append( - {"Description": "plot of similarity vs resolution", "path": plot_loc}, - ignore_index=True, - ) - - # save out manifest - manifest_save_path = self.step_local_staging_dir / "manifest.csv" - self.manifest.to_csv(manifest_save_path) - - return manifest_save_path diff --git a/cvapipe_analysis/steps/multi_res_struct_compare/utils.py b/cvapipe_analysis/steps/multi_res_struct_compare/utils.py deleted file mode 100644 index 3b24ca8..0000000 --- a/cvapipe_analysis/steps/multi_res_struct_compare/utils.py +++ /dev/null @@ -1,481 +0,0 @@ -from pathlib import Path - -import numpy as np -import pandas as pd -import logging - -from scipy.stats import pearsonr, gmean -from skimage.measure import block_reduce -from skimage.util import crop -from scipy.special import comb - -# from typing import List, Union, Optional - -import matplotlib.pyplot as plt -import seaborn as sns - -from aicsimageio import AICSImage - -from .constants import ( - DatasetFieldsMorphed, - DatasetFieldsIC, - DatasetFieldsAverageMorphed, - StructureGenes, -) - -############################################################################### - -log = logging.getLogger(__name__) - -############################################################################### - - -def make_5d_stack_cross_corr_dataframe(num_structs, num_bins): - - N_Pairs = comb(num_structs, 2, exact=True) - - channel_pairs = draw_pairs(np.arange(num_structs), n_pairs=N_Pairs) - - # Make dataset of cross correlation indices - dataset = pd.DataFrame() - - # Structure Genes - GeneOrder = list(StructureGenes.__dict__.values())[1:-3] - - for bins in range(num_bins): - this_dataset = pd.DataFrame( - channel_pairs, columns=["ChannelIndex_i", "ChannelIndex_j"] - ) - this_dataset["PC_bin"] = bins - this_dataset["ChannelGeneName_i"] = this_dataset["ChannelIndex_i"].apply( - lambda x: GeneOrder[x] - ) - this_dataset["ChannelGeneName_j"] = this_dataset["ChannelIndex_j"].apply( - lambda x: GeneOrder[x] - ) - dataset = dataset.append(this_dataset) - - return dataset - - -def blockreduce_pyramid(input_arr, block_size=(2, 2, 2), func=np.max, max_iters=12): - """ - Parameters - ---------- - input_arr: np.array - Input array to iteratively downsample - Default: Path("local_staging/singlecellimages/manifest.csv") - block_size: Tuple(int) - Block size for iterative array reduction. All voxels in this block - are merged via func into one voxel during the downsample. - Default: (2, 2, 2) - func: Callable[[np.array], float] - Function to apply to block_size voxels to merge them into one new voxel. - Default: np.max - max_iters: int - Maximum number of downsampling rounds before ending at a one voxel cell. - Default: 12 - Returns - ------- - result: Dict[float, np.array] - Dictionary of reduced arrays. - Keys are reduction fold, values the reduced array. - """ - - # how much are we downsampling per round - fold = gmean(block_size) - - # original image - i = 0 - pyramid = {fold ** i: input_arr.copy()} - - # downsample and save to dict - i = 1 - while (i <= max_iters) and (np.max(pyramid[fold ** (i - 1)].shape) > 1): - pyramid[fold ** i] = block_reduce(pyramid[fold ** (i - 1)], block_size, func) - i += 1 - - return pyramid - - -def safe_pearsonr(arr1, arr2): - """Sensibly handle degenerate cases.""" - assert arr1.shape == arr2.shape - - imgs_same = np.all(arr1 == arr2) - stdv_1_zero = len(np.unique(arr1)) == 1 - stdv_2_zero = len(np.unique(arr2)) == 1 - - if (stdv_1_zero | stdv_2_zero) & imgs_same: - corr = 1.0 - elif (stdv_1_zero | stdv_2_zero) & (not imgs_same): - corr = 0.0 - else: - corr, _ = pearsonr(arr1, arr2) - - return corr - - -def pyramid_correlation( - img1, img2, mask1=None, mask2=None, permute=False, **pyramid_kwargs -): - # make sure inputs are all the same shape - assert img1.shape == img2.shape - if mask1 is None: - mask1 = np.ones_like(img1) - assert mask1.shape == img1.shape - - if mask2 is None: - mask2 = np.ones_like(img2) - assert mask2.shape == img2.shape - - # make image pyramids - pyramid_1 = blockreduce_pyramid(img1, **pyramid_kwargs) - pyramid_2 = blockreduce_pyramid(img2, **pyramid_kwargs) - - # also make a mask pyramid - mask_kwargs = pyramid_kwargs.copy() - mask_kwargs["func"] = np.max - - pyramid_mask_1 = blockreduce_pyramid(mask1, **mask_kwargs) - - if (mask1 == mask2).all(): - pyramid_mask_2 = pyramid_mask_1 - else: - pyramid_mask_2 = blockreduce_pyramid(mask2, **mask_kwargs) - - # make sure everything has the same keys - assert pyramid_1.keys() == pyramid_2.keys() - assert pyramid_mask_1.keys() == pyramid_1.keys() - assert pyramid_mask_2.keys() == pyramid_2.keys() - - pyramid_1_masked_flat = {k: v.flatten() for k, v in pyramid_1.items()} - pyramid_2_masked_flat = {k: v.flatten() for k, v in pyramid_2.items()} - - # at each resolution, find corr - if not permute: - corrs = { - k: safe_pearsonr(pyramid_1_masked_flat[k], pyramid_2_masked_flat[k]) - for k in sorted( - set({**pyramid_1_masked_flat, **pyramid_2_masked_flat}.keys()) - ) - } - else: - # shuffle voxels in one pyramid if we want the permuted baseline - pyramid_1_masked_flat_permuted = pyramid_1_masked_flat.copy() - for k in pyramid_1_masked_flat_permuted.keys(): - np.random.shuffle(pyramid_1_masked_flat[k]) - corrs = { - k: safe_pearsonr( - pyramid_1_masked_flat_permuted[k], pyramid_2_masked_flat[k] - ) - for k in sorted( - set({**pyramid_1_masked_flat_permuted, **pyramid_2_masked_flat}.keys()) - ) - } - - return corrs - - -def get_cell_mask(image_path, crop_size=(64, 160, 96), cell_mask_channel_ind=1): - """ - Take a path to a tiff and return the masked gfp 3d volume - """ - - # load image - image = AICSImage(image_path) - data_6d = image.data - mask_3d = data_6d[0, 0, cell_mask_channel_ind, :, :, :] - - # crop to desired shape - z_dim, y_dim, x_dim = mask_3d.shape - z_desired, y_desired, x_desired = crop_size - z_crop = (z_dim - z_desired) // 2 - y_crop = (y_dim - y_desired) // 2 - x_crop = (x_dim - x_desired) // 2 - mask_3d = crop(mask_3d, ((z_crop, z_crop), (y_crop, y_crop), (x_crop, x_crop))) - assert mask_3d.shape == crop_size - - return mask_3d - - -def get_gfp_single_channel_img(image_path, crop_size=(64, 160, 96), gfp_channel_ind=0): - """ - Take a path to a tiff and return the masked gfp 3d volume - """ - - # load image - image = AICSImage(image_path) - data_6d = image.data - gfp_3d = data_6d[0, 0, gfp_channel_ind, :, :, :] - - # crop to desired shape - z_dim, y_dim, x_dim = gfp_3d.shape - z_desired, y_desired, x_desired = crop_size - z_crop = (z_dim - z_desired) // 2 - y_crop = (y_dim - y_desired) // 2 - x_crop = (x_dim - x_desired) // 2 - gfp_3d = crop(gfp_3d, ((z_crop, z_crop), (y_crop, y_crop), (x_crop, x_crop))) - assert gfp_3d.shape == crop_size - - return gfp_3d - - -def draw_pairs(input_list, n_pairs=1): - """ - Draw unique (ordered) pairs of examples from input_list at random. - Input list is not a list of pairs, just a list of single exemplars. - Example: - >>> draw_pairs([0,1,2,3], n_pairs=3) - >>> {(1,2), (2,3), (0,3)} - Note: - A pair is only unique up to order, e.g. (1,2) == (2,1). this function - only returns and compared sorted tuple to handle this - """ - - # make sure requested number of uniquepairs in possible - L = len(input_list) - assert n_pairs <= L * (L - 1) / 2 - - # draw n_pairs of size 2 sets from input_list - pairs = set() - while len(pairs) < n_pairs: - pairs |= {frozenset(sorted(np.random.choice(input_list, 2, replace=False)))} - - # return a set of ordered tuples to not weird people out - return {tuple(sorted(p)) for p in pairs} - - -def pct_normalization_and_8bit(raw, pct_range=[50, 99]): - msk = raw > 0 - values = raw[msk] - if len(values): - pcts = np.percentile(values, pct_range) - if pcts[1] > pcts[0]: - values = np.clip(values, *pcts) - values = (values - pcts[0]) / (pcts[1] - pcts[0]) - values = np.clip(values, 0, 1) - raw[msk] = 255 * values - return raw.astype(np.uint8) - - -def compute_distance_metric( - row, - input_5d_stack, - permuted, - px_size=0.29, - crop_size=(64, 160, 96), -): - """ - Main function to loop over in distributed - """ - - # Dataframe to grab correlations at each res in a df - df_tmp_corrs = pd.DataFrame() - - # Gets cells for IC dataframe - if all(elem in list(DatasetFieldsIC.__dict__.values()) for elem in row.index): - DatasetFields = DatasetFieldsIC - - # get data for cells i and j - img_i = get_gfp_single_channel_img( - row[DatasetFields.SourceReadPath1], crop_size=crop_size - ) - img_j = get_gfp_single_channel_img( - row[DatasetFields.SourceReadPath2], crop_size=crop_size - ) - - # get the mask for the cell - mask = get_cell_mask( - Path(row[DatasetFields.SaveDir]) - / Path(row[DatasetFields.SaveRegPath]).name, - crop_size=crop_size, - ) - # kill gfp intensity outside of mask - img_i[mask == 0] = 0 - img_j[mask == 0] = 0 - - mask_i = mask_j = mask - - # Get cells for Morphed cell dataframe - elif all( - elem in list(DatasetFieldsMorphed.__dict__.values()) for elem in row.index - ): - DatasetFields = DatasetFieldsMorphed - - all_img_i = AICSImage(row[DatasetFields.SourceReadPath1]).data[0, 0, :, :, :, :] - all_img_j = AICSImage(row[DatasetFields.SourceReadPath2]).data[0, 0, :, :, :, :] - - mask_i = all_img_i[0, :, :, :] + all_img_i[1, :, :, :] - mask_j = all_img_j[0, :, :, :] + all_img_j[1, :, :, :] - img_i = all_img_i[2, :, :, :] - img_j = all_img_j[2, :, :, :] - - # Adjust contast if it is the raw image - if DatasetFields.SourceReadPath1 == "path_raw_morph_1": - img_i = pct_normalization_and_8bit(img_i) - img_j = pct_normalization_and_8bit(img_j) - - img_i = img_i / img_i.max() - img_j = img_j / img_j.max() - - # kill intensity outside of mask - img_i[mask_i == 0] = 0 - img_j[mask_j == 0] = 0 - - # Get images from 5d stack - elif any( - elem in list(DatasetFieldsAverageMorphed.__dict__.values()) - for elem in row.index - ): - DatasetFields = DatasetFieldsAverageMorphed - - img_i = input_5d_stack[ - 0, row[DatasetFields.StructureIndex1], :, row[DatasetFields.PC_bin], :, : - ] - img_j = input_5d_stack[ - 0, row[DatasetFields.StructureIndex2], :, row[DatasetFields.PC_bin], :, : - ] - # -1 is CELL+NUC mask - mask = input_5d_stack[0, -1, :, row[DatasetFields.PC_bin], :, :] - img_i[mask == 0] = 0 - img_j[mask == 0] = 0 - mask_i = mask_j = mask - - try: - # multi-res comparison - pyr_corrs = pyramid_correlation( - img_i, img_j, mask1=mask_i, mask2=mask_j, func=np.mean - ) - - if permuted: - # comparison when one input is permuted (as baseline correlation) - pyr_corrs_permuted = pyramid_correlation( - img_i, img_j, mask1=mask_i, mask2=mask_j, permute=True, func=np.mean - ) - - for k, v in sorted(pyr_corrs.items()): - if permuted: - tmp_stat_dict = { - "Resolution (micrometers)": px_size * k, - "Pearson Correlation": v, - "Pearson Correlation permuted": pyr_corrs_permuted[k], - } - else: - tmp_stat_dict = { - "Resolution (micrometers)": px_size * k, - "Pearson Correlation": v, - } - - df_tmp_corrs = df_tmp_corrs.append(tmp_stat_dict, ignore_index=True) - - # label stats with StructureName1 - df_tmp_corrs[DatasetFields.StructureName1] = row[DatasetFields.StructureName1] - - # and append row metadata - df_row_tmp = row.to_frame().T - df_row_tmp = df_row_tmp.merge(df_tmp_corrs) - - return df_row_tmp - - # Catch ValueError when some of the flattened images have infinity or NaNs - # This generally throws a ValueError: array must not contain infs or NaNs - # in the pearson r calculation - except ValueError: - return None - - -def clean_up_results(dist_metric_results, permuted): - """ - Clean up distributed results. - """ - df_final = pd.DataFrame() - for dataframes in dist_metric_results: - for corr_dataframe in dataframes: - if corr_dataframe is not None: - df_final = df_final.append(corr_dataframe) - - # fix up final pairwise dataframe - df_final = df_final.reset_index(drop=True) - - if permuted: - df_final["Pearson Correlation gain over random"] = ( - df_final["Pearson Correlation"] - df_final["Pearson Correlation permuted"] - ) - - return df_final - - -def make_plot(data, plot_dir): - """ - Seaborn plot of mean corr gain over random vs resolution. - """ - sns.set(style="ticks", rc={"lines.linewidth": 1.0}) - - if "GeneratedStructureName_i" in data.columns: - fig = plt.figure(figsize=(10, 7)) - ax = sns.pointplot( - x="Resolution (micrometers)", - y="Pearson Correlation", - hue="GeneratedStructureName_i", - data=data, - ci=95, - capsize=0.2, - palette="Set2", - ) - ax.legend( - loc="upper left", - bbox_to_anchor=(0.05, 0.95), - ncol=1, - frameon=False, - ) - sns.despine( - offset=0, - trim=True, - ) - # save the plot - fig.savefig( - plot_dir / "multi_resolution_image_correlation.png", - format="png", - dpi=300, - transparent=True, - ) - elif "StructureName_1" in data.columns: - - data = data[data.StructureName_1 != "CELL+NUCLEUS"] - data = data[data.StructureName_2 != "CELL+NUCLEUS"] - - for this_bin in range(7): - fig = plt.figure(figsize=(10, 7)) - plot_data = data.loc[(data["bin"] == this_bin)] - - ax = sns.pointplot( - x="Resolution (micrometers)", - y="Pearson Correlation", - hue="StructureName_1", - data=plot_data, - ci=95, - dodge=True, - capsize=0.2, - palette="Set2", - ) - - ax.legend( - loc="best", - bbox_to_anchor=(1, 0.95), - ncol=2, - frameon=False, - ) - ax.set_title(f"Bin {this_bin}") - sns.despine( - offset=0, - trim=True, - ) - - plt.tight_layout() - fig.savefig( - plot_dir / f"multi_resolution_image_correlation_bin_{this_bin}.png", - format="png", - dpi=300, - transparent=True, - ) diff --git a/cvapipe_analysis/steps/parameterization/parameterization.py b/cvapipe_analysis/steps/parameterization/parameterization.py index b4a5b41..3290bd7 100644 --- a/cvapipe_analysis/steps/parameterization/parameterization.py +++ b/cvapipe_analysis/steps/parameterization/parameterization.py @@ -7,7 +7,7 @@ from typing import Dict, List, Optional, Union import concurrent -from cvapipe_analysis.tools import io, general, cluster +from ...tools import io, general, cluster from .parameterization_tools import Parameterizer log = logging.getLogger(__name__) @@ -21,26 +21,34 @@ def __init__( super().__init__(direct_upstream_tasks=direct_upstream_tasks, config=config) @log_run_params - def run(self, distribute: Optional[bool]=False, **kwargs): + def run( + self, + staging: Union[str, Path], + verbose: Optional[bool]=False, + distribute: Optional[bool]=False, + **kwargs): + + step_dir = Path(staging) / self.step_name - with general.configuration(self.step_local_staging_dir) as control: + with general.configuration(step_dir) as control: + + control.create_step_subdirs(step_dir, ["representations"]) device = io.LocalStagingIO(control) df = device.load_step_manifest("preprocessing") log.info(f"Manifest: {df.shape}") - save_dir = self.step_local_staging_dir/"representations" - save_dir.mkdir(parents=True, exist_ok=True) - if distribute: distributor = cluster.ParameterizationDistributor(self, control) distributor.set_data(df) distributor.distribute() - log.info(f"Multiple jobs have been launched. Please come back when the calculation is complete.") + distributor.jobs_warning() return None parameterizer = Parameterizer(control) + if verbose: + parameterizer.set_verbose_mode_on() with concurrent.futures.ProcessPoolExecutor(control.get_ncores()) as executor: executor.map(parameterizer.execute, [row for _,row in df.iterrows()]) diff --git a/cvapipe_analysis/steps/parameterization/parameterization_tools.py b/cvapipe_analysis/steps/parameterization/parameterization_tools.py index dc096ae..4c1dcd6 100644 --- a/cvapipe_analysis/steps/parameterization/parameterization_tools.py +++ b/cvapipe_analysis/steps/parameterization/parameterization_tools.py @@ -23,17 +23,21 @@ def __init__(self, config): def workflow(self): + self.print("Loading single cell images...") self.load_single_cell_data() + self.print("Aligning images...") self.align_data() alias_outer = self.control.get_outer_most_alias_to_parameterize() alias_inner = self.control.get_inner_most_alias_to_parameterize() + self.print("Finding SHE...") coeffs_outer, centroid_outer = self.find_shcoeffs_and_centroid(alias_outer) coeffs_inner, centroid_inner = self.find_shcoeffs_and_centroid(alias_inner) named_imgs = self.get_list_of_imgs_to_create_representation_for() + self.print("Getting representation...") n = self.control.get_number_of_interpolating_points() self.representations = cytoparam.parameterization_from_shcoeffs( coeffs_mem = coeffs_outer, @@ -77,13 +81,14 @@ def find_shcoeffs_and_centroid(self, alias): if __name__ == "__main__": - config = general.load_config_file() - control = controller.Controller(config) - - parser = argparse.ArgumentParser(description='Batch single cell parameterization.') - parser.add_argument('--csv', help='Path to the dataframe.', required=True) + parser = argparse.ArgumentParser(description="Batch single cell feature extraction.") + parser.add_argument("--staging", help="Path to staging.", required=True) + parser.add_argument("--csv", help="Path to the dataframe.", required=True) args = vars(parser.parse_args()) + config = general.load_config_file(args["staging"]) + control = controller.Controller(config) + df = pd.read_csv(args['csv'], index_col='CellId') print(f"Processing dataframe of shape {df.shape}") diff --git a/cvapipe_analysis/steps/pca_path_cells/__init__.py b/cvapipe_analysis/steps/pca_path_cells/__init__.py deleted file mode 100644 index 2edf518..0000000 --- a/cvapipe_analysis/steps/pca_path_cells/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -# -*- coding: utf-8 -*- - -from .pca_path_cells import PcaPathCells # noqa: F401 - -__all__ = ["PcaPathCells"] diff --git a/cvapipe_analysis/steps/pca_path_cells/pca_path_cells.py b/cvapipe_analysis/steps/pca_path_cells/pca_path_cells.py deleted file mode 100644 index 9836f59..0000000 --- a/cvapipe_analysis/steps/pca_path_cells/pca_path_cells.py +++ /dev/null @@ -1,143 +0,0 @@ -import logging -from pathlib import Path -from typing import Dict, List, Optional, Union - -import numpy as np -import pandas as pd - -from datastep import Step, log_run_params -from .utils import scan_pc_for_cells - -############################################################################### - -log = logging.getLogger(__name__) - -############################################################################### - - -class PcaPathCells(Step): - def __init__( - self, - direct_upstream_tasks: List["Step"] = [], - config: Optional[Union[str, Path, Dict[str, str]]] = None, - filepath_columns=["dataframe_loc"], - ): - super().__init__(direct_upstream_tasks=direct_upstream_tasks, config=config) - - @log_run_params - def run( - self, - pca_csv_loc=Path( - "/allen/aics/assay-dev/MicroscopyOtherData/Viana/projects/" - "cell_shape_variation/local_staging/expand/manifest.csv" - ), - pcs=[ - "DNA_MEM_PC1", - "DNA_MEM_PC2", - "DNA_MEM_PC3", - "DNA_MEM_PC4", - "DNA_MEM_PC5", - "DNA_MEM_PC6", - "DNA_MEM_PC7", - "DNA_MEM_PC8", - ], - path_in_stdv=np.array([-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0]), - dist_cols=[ - "DNA_MEM_PC1", - "DNA_MEM_PC2", - "DNA_MEM_PC3", - "DNA_MEM_PC4", - "DNA_MEM_PC5", - "DNA_MEM_PC6", - "DNA_MEM_PC7", - "DNA_MEM_PC8", - ], - metric="euclidean", - id_col="CellId_old", - N_cells=1, - **kwargs, - ): - """ - Look through PCA embeddings of cells to find groups of cells closest to PC axes. - Parameters - ---------- - pca_csv_loc: pathlib.Path - Location of csv containing pca embeddings of cells - Default: Path("/allen/aics/assay-dev/MicroscopyOtherData/Viana/forCaleb/"\ - "variance/05202020_Align-IND_Chirality-OFF/manifest.csv") - pcs: List[int] - Which pcs do we want to trace through - Default: [ - "DNA_MEM_PC1", - "DNA_MEM_PC2", - "DNA_MEM_PC3", - "DNA_MEM_PC4", - "DNA_MEM_PC5", - "DNA_MEM_PC6", - "DNA_MEM_PC7", - "DNA_MEM_PC8", - ] - path_in_stdv: np.array - Path containing points along each PC axis where we find nearest cells. - Units are in stdv of that dimension. - Default: np.array([-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0]) - dist_cols: List[str] - Which columns in the `pca_csv_loc` contribute to distance computations? - Default: [ - 'DNA_MEM_PC1', - 'DNA_MEM_PC2', - 'DNA_MEM_PC3', - 'DNA_MEM_PC4', - 'DNA_MEM_PC5', - 'DNA_MEM_PC6', - 'DNA_MEM_PC7', - 'DNA_MEM_PC8' - ] - metric: str - How do we compute distance? Passed to scipy.spatial.distance.cdist - Default: "euclidean" - id_col: str - Which column in `pca_csv_loc` is used for unique cell ids? - Default: "CellId" - N_cells: int - How many nearest cells to each point on `path` are returned? - Default: 3 - Returns - ------- - result: pathlib.Path - Path to manifest - """ - - self.manifest = pd.DataFrame(columns=["PC", "dataframe_path"]) - pc_path_dir = self.step_local_staging_dir / "pc_paths" - pc_path_dir.mkdir(parents=True, exist_ok=True) - - # TODO change this filepath location to an upstream step - df_pca = pd.read_csv(pca_csv_loc) - - for pc in pcs: - - pc_stdv = df_pca[pc].std() - - df_cells = scan_pc_for_cells( - df_pca, - pc=pc, - path=np.array(path_in_stdv) * pc_stdv, - dist_cols=dist_cols, - metric=metric, - id_col=id_col, - N_cells=N_cells, - ) - - fpath = pc_path_dir / f"pca_{pc}_path_cells.csv" - df_cells.to_csv(fpath, index=False) - - self.manifest = self.manifest.append( - {"PC": pc, "dataframe_path": fpath}, ignore_index=True - ) - - self.manifest = self.manifest.reset_index(drop=True) - manifest_save_path = self.step_local_staging_dir / "manifest.csv" - self.manifest.to_csv(manifest_save_path) - - return manifest_save_path diff --git a/cvapipe_analysis/steps/pca_path_cells/utils.py b/cvapipe_analysis/steps/pca_path_cells/utils.py deleted file mode 100644 index 2283791..0000000 --- a/cvapipe_analysis/steps/pca_path_cells/utils.py +++ /dev/null @@ -1,87 +0,0 @@ -import numpy as np -import pandas as pd -from scipy.spatial.distance import cdist - - -def find_closest_cells( - df, - dist_cols=[ - "DNA_MEM_PC1", - "DNA_MEM_PC2", - "DNA_MEM_PC3", - "DNA_MEM_PC4", - "DNA_MEM_PC5", - "DNA_MEM_PC6", - "DNA_MEM_PC7", - "DNA_MEM_PC8", - ], - metric="euclidean", - id_col="CellId", - N_cells=10, - location=np.array([0, 0, 0, 0, 0, 0, 0, 0]), -): - """ - looks through df and finds N closest cells (rows) to location - using all dist_cols as equally weighted embedding dimensions - metric can be any string that works with scipy.spatial.distance.cdist - Returns a len(N_cells) df of cell ids and columns matching dist_cols_pattern - cells are sorted by distance and also have an additional columns of overall distance - """ - - loc_2d = np.expand_dims(location, 0) - dists = np.squeeze(cdist(df[dist_cols], loc_2d, metric)) - dist_col = f"{metric} distance to location" - loc_str = ", ".join([f"{loc:.3f}" for loc in location]) - df_dists = pd.DataFrame({dist_col: dists, "location": [loc_str] * len(df)}) - - df_ids_and_dims = df[[id_col, *dist_cols]] - - df_out = pd.concat([df_ids_and_dims, df_dists], axis="columns") - - return ( - df_out.sort_values(by=[dist_col]) - .head(N_cells) - .reindex([id_col, "location", dist_col, *dist_cols], axis="columns") - ) - - -def scan_pc_for_cells( - df, - pc=1, - path=np.array([-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0]), - dist_cols=[ - "DNA_MEM_PC1", - "DNA_MEM_PC2", - "DNA_MEM_PC3", - "DNA_MEM_PC4", - "DNA_MEM_PC5", - "DNA_MEM_PC6", - "DNA_MEM_PC7", - "DNA_MEM_PC8", - ], - metric="euclidean", - id_col="CellId", - N_cells=10, -): - """ - scans pc along path for N_cells closest to each point on path - """ - - df_out = pd.DataFrame() - - for p in path: - point = np.zeros(len(dist_cols)) - point[pc - 1] = p - - df_point = find_closest_cells( - df, - dist_cols=dist_cols, - metric=metric, - id_col=id_col, - N_cells=N_cells, - location=point, - ) - - df_out = df_out.append(df_point) - - return df_out diff --git a/cvapipe_analysis/steps/preprocessing/preprocessing.py b/cvapipe_analysis/steps/preprocessing/preprocessing.py index d6ce031..a8bc166 100644 --- a/cvapipe_analysis/steps/preprocessing/preprocessing.py +++ b/cvapipe_analysis/steps/preprocessing/preprocessing.py @@ -7,7 +7,7 @@ from typing import Dict, List, Optional, Union import pandas as pd -from cvapipe_analysis.tools import io, general +from ...tools import io, general from .outliers_tools import outliers_removal from .filtering_tools import filtering @@ -25,13 +25,19 @@ def __init__( @log_run_params def run( self, + staging: Union[str, Path], + verbose: Optional[bool]=False, filter = None, debug: bool=False, **kwargs ): - with general.configuration(self.step_local_staging_dir) as control: + step_dir = Path(staging) / self.step_name + + with general.configuration(step_dir) as control: + control.create_step_subdirs(step_dir, ["outliers"]) + device = io.LocalStagingIO(control) df = device.load_step_manifest("computefeatures") log.info(f"Shape of manifest: {df.shape}") @@ -44,23 +50,17 @@ def run( log.info(f"Manifest without mitotics: {df.shape}") if control.remove_outliers(): - - path_to_outliers_folder = self.step_local_staging_dir/"outliers" - path_to_outliers_folder.mkdir(parents=True, exist_ok=True) - path_to_df_outliers = self.step_local_staging_dir/"outliers.csv" - if not path_to_df_outliers.is_file() or control.overwrite(): + if "outlier" not in df.columns: + # Compute outliers in case it is not available + path_to_df_outliers = step_dir/"outliers.csv" log.info("Computing outliers...") - df_outliers = outliers_removal(df=df, output_dir=path_to_outliers_folder, log=log) - df_outliers.to_csv(path_to_df_outliers) - else: - log.info("Using pre-detected outliers.") - df_outliers = pd.read_csv(path_to_df_outliers, index_col='CellId') + df_outliers = outliers_removal(df=df, output_dir=step_dir/"outliers", log=log) + df_outliers = df_outliers.loc[df.index] + df.loc[df_outliers.index, 'outlier'] = df_outliers['Outlier'] - df_outliers = df_outliers.loc[df.index] - df.loc[df_outliers.index, 'Outlier'] = df_outliers['Outlier'] - df = df.loc[df.Outlier == 'No'] - df = df.drop(columns=['Outlier']) + df = df.loc[df.outlier == 'No'] + df = df.drop(columns=['outlier']) log.info(f"Shape of data without outliers: {df.shape}") if control.is_filtering_on(): @@ -79,7 +79,7 @@ def run( log.info(f"Saving manifest...") self.manifest = df - manifest_path = self.step_local_staging_dir/'manifest.csv' + manifest_path = step_dir/'manifest.csv' self.manifest.to_csv(manifest_path) return manifest_path diff --git a/cvapipe_analysis/steps/shapemode/__init__.py b/cvapipe_analysis/steps/shapemode/__init__.py index efd5516..40a96af 100644 --- a/cvapipe_analysis/steps/shapemode/__init__.py +++ b/cvapipe_analysis/steps/shapemode/__init__.py @@ -1,5 +1 @@ # -*- coding: utf-8 -*- - -from .shapemode import Shapemode # noqa: F401 - -__all__ = ["Shapemode"] diff --git a/cvapipe_analysis/steps/shapemode/avgshape.py b/cvapipe_analysis/steps/shapemode/avgshape.py deleted file mode 100644 index d05e2f0..0000000 --- a/cvapipe_analysis/steps/shapemode/avgshape.py +++ /dev/null @@ -1,801 +0,0 @@ -import vtk -import math -import operator -import warnings -import numpy as np -import pandas as pd -from pathlib import Path -from functools import reduce -import matplotlib.pyplot as plt -from aicsshparam import shtools -from matplotlib import animation -from typing import Dict, List, Optional, Union -from aics_dask_utils import DistributedHandler -from vtk.util.numpy_support import vtk_to_numpy, numpy_to_vtk - -from .dim_reduction import pPCA - -def filter_extremes_based_on_percentile( - df: pd.DataFrame, - features: List, - pct: float -): - - """ - Exclude extreme data points that fall in the percentile range - [0,pct] or [100-pct,100] of at least one of the features - provided. - - Parameters - -------------------- - df: pandas df - Input dataframe that contains the features. - features: List - List of column names to be used to filter the data - points. - pct: float - Specifies the percentile range; data points that - fall in the percentile range [0,pct] or [100-pct,100] - of at least one of the features are removed. - - Returns - ------- - df: pandas dataframe - Filtered dataframe. - """ - - # Temporary column to store whether a data point is an - # extreme point or not. - df["extreme"] = False - - for f in features: - - # Calculated the extreme interval fot the current feature - finf, fsup = np.percentile(df[f].values, [pct, 100 - pct]) - - # Points in either high or low extreme as flagged - df.loc[(df[f] < finf), "extreme"] = True - df.loc[(df[f] > fsup), "extreme"] = True - - # Drop extreme points and temporary column - df = df.loc[df.extreme == False] - df = df.drop(columns=["extreme"]) - - return df - - -def digitize_shape_mode( - df: pd.DataFrame, - feature: List, - nbins: int, - filter_based_on: List, - filter_extremes_pct: float = 1, - save: Optional[Path] = None, - return_freqs_per_structs: Optional[bool] = False -): - - """ - Discretize a given feature into nbins number of equally - spaced bins. The feature is first z-scored and the interval - from -2std to 2std is divided into nbins bins. - - Parameters - -------------------- - df: pandas df - Input dataframe that contains the feature to be - discretized. - features: str - Column name of the feature to be discretized. - nbins: int - Number of bins to divide the feature into. - filter_extremes_pct: float - See parameter pct in function filter_extremes_based_on_percentile - filter_based_on: list - List of all column names that should be used for - filtering extreme data points. - save: Path - Path to a file where we save the number of data points - that fall in each bin - return_freqs_per_structs: bool - Wheter or not to return a dataframe with the number of - data points in each bin stratifyied by structure_name. - Returns - ------- - df: pandas dataframe - Input dataframe with data points filtered according - to filter_extremes_pct plus a column named "bin" - that denotes the bin in which a given data point - fall in. - bin_indexes: list of tuples - [(a,b)] where a is the bin number and b is a list - with the index of all data points that fall into - that bin. - bin_centers: list - List with values of feature at the center of each - bin - pc_std: float - Standard deviation used to z-score the feature. - df_freq: pd.DataFrame - dataframe with the number of data points in each - bin stratifyied by structure_name (returned only - when return_freqs_per_structs is set to True). - - """ - - # Check if feature is available - if feature not in df.columns: - raise ValueError(f"Column {feature} not found.") - - # Exclude extremeties - df = filter_extremes_based_on_percentile( - df = df, - features = filter_based_on, - pct = filter_extremes_pct - ) - - # Get feature values - values = df[feature].values.astype(np.float32) - - # Should be centered already, but enforce it here - values -= values.mean() - # Z-score - - pc_std = values.std() - values /= pc_std - - # Calculate bin half width based on std interval and nbins - LINF = -2.0 # inferior limit = -2 std - LSUP = 2.0 # superior limit = 2 std - binw = (LSUP-LINF)/(2*(nbins-1)) - - # Force samples below/above -/+ 2std to fall into first/last bin - bin_centers = np.linspace(LINF, LSUP, nbins) - bin_edges = np.unique([(b-binw, b+binw) for b in bin_centers]) - bin_edges[0] = -np.inf - bin_edges[-1] = np.inf - - # Aplly digitization - df["bin"] = np.digitize(values, bin_edges) - - # Report number of data points in each bin - df_freq = pd.DataFrame(df["bin"].value_counts(sort=False)) - df_freq.index = df_freq.index.rename(f"{feature}_bin") - df_freq = df_freq.rename(columns={"bin": "samples"}) - if save is not None: - with open(f"{save}.txt", "w") as flog: - print(df_freq, file=flog) - - # Store the index of all data points in each bin - bin_indexes = [] - df_agg = df.groupby(["bin"]).mean() - for b, df_bin in df.groupby(["bin"]): - bin_indexes.append((b, df_bin.index)) - - # Optionally return a dataframe with the number of data - # points in each bin stratifyied by structure_name. - if return_freqs_per_structs: - - df_freq = ( - df[["structure_name", "bin"]].groupby(["structure_name", "bin"]).size() - ) - df_freq = pd.DataFrame(df_freq) - df_freq = df_freq.rename(columns={0: "samples"}) - df_freq = df_freq.unstack(level=1) - return df, bin_indexes, (bin_centers, pc_std), df_freq - - return df, bin_indexes, (bin_centers, pc_std) - -def find_plane_mesh_intersection( - proj: List, - mesh: vtk.vtkPolyData -): - - """ - Determine the points of mesh that intersect with the - plane defined by the proj: - - Parameters - -------------------- - proj: List - One of [0,1], [0,2] or [1,2] for xy-plane, xz-plane - and yz-plane, respectively. - mesh: vtk.vtkPolyData - Input triangle mesh. - Returns - ------- - points: np.array - Nx3 array of xyz coordinates of mesh points - that intersect the plane. - """ - - # Find axis orthogonal to the projection of interest - ax = [a for a in [0, 1, 2] if a not in proj][0] - - # Get all mesh points - points = vtk_to_numpy(mesh.GetPoints().GetData()) - - if not np.abs(points[:, ax]).sum(): - raise Exception("Only zeros found in the plane axis.") - - mid = np.mean(points[:, ax]) - - # Set the plane a little off center to avoid undefined intersections - # Without this the code hangs when the mesh has any edge aligned with the - # projection plane - mid += 0.75 - offset = 0.1 * np.ptp(points, axis=0).max() - - # Create a vtkPlaneSource - plane = vtk.vtkPlaneSource() - plane.SetXResolution(4) - plane.SetYResolution(4) - if ax == 0: - plane.SetOrigin(mid, points[:, 1].min() - offset, points[:, 2].min() - offset) - plane.SetPoint1(mid, points[:, 1].min() - offset, points[:, 2].max() + offset) - plane.SetPoint2(mid, points[:, 1].max() + offset, points[:, 2].min() - offset) - if ax == 1: - plane.SetOrigin(points[:, 0].min() - offset, mid, points[:, 2].min() - offset) - plane.SetPoint1(points[:, 0].min() - offset, mid, points[:, 2].max() + offset) - plane.SetPoint2(points[:, 0].max() + offset, mid, points[:, 2].min() - offset) - if ax == 2: - plane.SetOrigin(points[:, 0].min() - offset, points[:, 1].min() - offset, mid) - plane.SetPoint1(points[:, 0].min() - offset, points[:, 1].max() + offset, mid) - plane.SetPoint2(points[:, 0].max() + offset, points[:, 1].min() - offset, mid) - plane.Update() - plane = plane.GetOutput() - - # Trangulate the plane - triangulate = vtk.vtkTriangleFilter() - triangulate.SetInputData(plane) - triangulate.Update() - plane = triangulate.GetOutput() - - # Calculate intersection - intersection = vtk.vtkIntersectionPolyDataFilter() - intersection.SetInputData(0, mesh) - intersection.SetInputData(1, plane) - intersection.Update() - intersection = intersection.GetOutput() - - # Get coordinates of intersecting points - points = vtk_to_numpy(intersection.GetPoints().GetData()) - - # Sorting points clockwise - # This has been discussed here: - # https://stackoverflow.com/questions/51074984/sorting-according-to-clockwise-point-coordinates/51075469 - # but seems not to be very efficient. Better version is proposed here: - # https://stackoverflow.com/questions/57566806/how-to-arrange-the-huge-list-of-2d-coordinates-in-a-clokwise-direction-in-python - coords = points[:, proj] - center = tuple( - map( - operator.truediv, - reduce(lambda x, y: map(operator.add, x, y), coords), - [len(coords)] * 2, - ) - ) - coords = sorted( - coords, - key=lambda coord: ( - -135 - - math.degrees(math.atan2(*tuple(map(operator.sub, coord, center))[::-1])) - ) - % 360, - ) - - # Store sorted coordinates - points[:, proj] = coords - - return points - - -def get_shcoeff_matrix_from_dataframe( - row: pd.Series, - prefix: str, - lmax: int -): - - """ - Reshape spherical harmonics expansion (SHE) coefficients - into a coefficients matrix of shape 2 x lmax x lmax, where - lmax is the degree of the expansion. - - Parameters - -------------------- - row: pd.Series - Series that contains the SHE coefficients. - prefix: str - String to identify the keys of the series that contain - the SHE coefficients. - lmax: int - Degree of the expansion - Returns - ------- - coeffs: np.array - Array of shape 2 x lmax x lmax that contains the - SHE coefficients. - """ - - # Empty matrix to store the SHE coefficients - coeffs = np.zeros((2, lmax, lmax), dtype=np.float32) - - for l in range(lmax): - for m in range(l + 1): - try: - # Cosine SHE coefficients - coeffs[0, l, m] = row[[f for f in row.keys() if f"{prefix}{l}M{m}C" in f]] - # Sine SHE coefficients - coeffs[1, l, m] = row[[f for f in row.keys() if f"{prefix}{l}M{m}S" in f]] - # If a given (l,m) pair is not found, it is - # assumed to be zero - except: - pass - - # Error if no coefficients were found. - if not np.abs(coeffs).sum(): - raise Exception( - f"No coefficients found. Please check prefix: {prefix}" - ) - - return coeffs - -def get_mesh_from_dataframe( - row: pd.Series, - prefix: str, - lmax: int -): - - """ - Reconstruct the 3D triangle mesh corresponding to SHE - coefficients stored in a pandas Series format. - - Parameters - -------------------- - row: pd.Series - Series that contains the SHE coefficients. - prefix: str - String to identify the keys of the series that contain - the SHE coefficients. - lmax: int - Degree of the expansion - Returns - ------- - mesh: vtk.vtkPolyData - Triangle mesh. - """ - - # Reshape SHE coefficients - coeffs = get_shcoeff_matrix_from_dataframe( - row = row, - prefix = prefix, - lmax = lmax - ) - - # Use aicsshparam to convert SHE coefficients into - # triangle mesh - mesh, _ = shtools.get_reconstruction_from_coeffs(coeffs) - - return mesh - - -def get_contours_of_consecutive_reconstructions( - df: pd.DataFrame, - prefix: str, - proj: List, - lmax: int -): - - """ - Reconstruct the 3D triangle mesh corresponding to SHE - coefficients per index of the input dataframe and finds - the intersection between this mesh and a plane defined - by the input variable proj. The intersection serves as - a 2D contour of the mesh. - - Parameters - -------------------- - df: pd.DataFrame - dataframe that contains SHE coefficients that will be - used to reconstruct a triangle mesh per index. - prefix: str - String to identify the keys of the series that contain - the SHE coefficients. - proj: List - One of [0,1], [0,2] or [1,2] for xy-plane, xz-plane - and yz-plane, respectively. - lmax: int - Degree of the expansion - Returns - ------- - contours: List - List of xyz points that intersect the reconstrcuted - meshes and the plane defined by proj. One per index. - meshes: List - List of reconstructed meshes. One per index. - limits: List - List of limits of reconstructed meshes. One per - index. - TBD - --- - - - Set bin as index of the dataframe outside this - function. - - """ - - if "bin" in df.columns: - df = df.set_index("bin") - - meshes = [] - limits = [] - contours = [] - - for index, row in df.iterrows(): - - # Get mesh of current index - mesh = get_mesh_from_dataframe( - row = row, - prefix = prefix, - lmax = lmax - ) - - # Find intersection between current mesh and plane - # defined by the input projection. - proj_points = find_plane_mesh_intersection(proj=proj, mesh=mesh) - - # Find x, y and z limits of mesh points coordinates - limit = mesh.GetBounds() - - meshes.append(mesh) - limits.append(limit) - contours.append(proj_points) - - return contours, meshes, limits - -def get_shcoeffs_from_pc_coords( - coords: np.array, - pc: int, - pca: pPCA -): - - """ - Uses the inverse PCA transform to convert one or more PC - coordiantes back into SHE coefficients. - - Parameters - -------------------- - coords: np.array - One or more values along the principal component - denoted by pc. - pc: int - Integer that denotes the principal components the - coordinates refer to. - pca: sklearn.decomposition.PCA - PCA object to be used. - Returns - ------- - df_coeffs: pd.DataFrame - DataFrame that stores the SHE coefficients. - - TBD: - Class for PCA object that stores the features names. - """ - - # coords has shape (N,) - npts = len(coords) - # Creates a matrix of shape (N,M), where M is the - # reduced dimension - pc_coords = np.zeros((npts, pca.get_pca().n_components), dtype=np.float32) - # Copy input coordinates to the matrix - pc_coords[:, pc] = coords - # Uses inverse PCA and stores result into a dataframe - df_coeffs = pd.DataFrame(pca.get_pca().inverse_transform(pc_coords)) - df_coeffs.columns = pca.get_feature_names() - df_coeffs.index = np.arange(1, 1 + npts) - - return df_coeffs - -def transform_coords_to_mem_space( - xo: float, - yo: float, - zo: float, - angle: float, - cm: List -): - - """ - Converts a xyz-coordinate into coordinate system of - aligned cell, defined by the angle and cell centroid. - - Parameters - -------------------- - xo: float - x-coordinate - yo: float - y-coordinate - zo: float - z-coordinate - angle: float - Cell alignment angle in degrees. - cm: tuple - xyz-coordinates of cell centroid. - Returns - ------- - xt: float - Transformed x-coodinate - yt: float - Transformed y-coodinate - zt: float - Transformed z-coodinate - """ - - angle = np.pi * angle / 180.0 - - rot_mx = np.array( - [ - [np.cos(angle), np.sin(angle), 0], - [-np.sin(angle), np.cos(angle), 0], - [0, 0, 1], - ] - ) - - pt_rot = np.matmul(rot_mx, np.array([xo-cm[0], yo-cm[1], zo-cm[2]])) - - xt = pt_rot[0] - yt = pt_rot[1] - zt = pt_rot[2] - - return xt, yt, zt - -def animate_shape_modes_and_save_meshes( - df_agg: pd.DataFrame, - mode: str, - save: Path, - plot_limits: Optional[List] = None, - fix_nuclear_position: Optional[bool] = None, - distributed_executor_address: Optional[str] = None, -): - - """ - Generate animated GIFs to illustrate cell and nuclear - shape variation as a single shape space dimension is - transversed. The function also saves the cell and - nuclear shape in VTK polydata format. - - Parameters - -------------------- - df_agg: pd.DataFrame - Dataframe that contains the cell and nuclear SHE - coefficients that will be reconstructed. Each line - of this dataframe will generate 3 animated GIFs: - one for each projection (xy, xz, and yz). - bin_indexes: List - [(a,b)] a's are integers for identifying the bin - number and b's are lists of all data points id's - that fall into that bin. - mode: str - Either DNA, MEM or DNA_MEM to specify whether the - shape space has been created based on nucleus, cell - or jointly combined cell and nuclear shape. - save: Path - Path to save results. - plot_limits: Optional[bool] = None - List of floats to be used as x-axis limits and - y-axis limits in the animated GIFs. Default values - used for the single-cell images dataset are - [-150, 150, -80, 80], - fix_nuclear_position: Tuple or None - Use None here to not change the nuclear location - relative to the cell. Otherwise, this should be a - tuple like (df,bin_indexes), where df is a single - cell dataframe that contains the columns necessary - to correct the nuclear location realtive to the cell. - bin_indexes is alist of tuple (a,b), where a is an - integer for that specifies the bin number and b is - a list of all data point ids from the single cell - dataframe that fall into that bin. - distributed_executor_address: Optionalstr = None - Dask executor address. - - Return - ------ - df_paths: pd.DataFrame - Dataframe with path for VTK meshes and GIF files - generated. - """ - - df_paths = [] - - if fix_nuclear_position is not None: - - df, bin_indexes = fix_nuclear_position - - def process_this_index(index_row): - ''' - Change the coordinate system of nuclear centroid - from nuclear to the aligned cell. - ''' - index, row = index_row - - dxc, dyc, dzc = transform_coords_to_mem_space( - xo = row["dna_position_x_centroid_lcc"], - yo = row["dna_position_y_centroid_lcc"], - zo = row["dna_position_z_centroid_lcc"], - # Cell alignment angle - angle = row["mem_shcoeffs_transform_angle_lcc"], - # Cell centroid - cm = [row[f"mem_position_{k}_centroid_lcc"] for k in ["x", "y", "z"]], - ) - - return (dxc, dyc, dzc) - - # Change the reference system of the vector that - # defines the nuclear location relative to the cell - # of all cells that fall into the same bin. - for (b, indexes) in bin_indexes: - # Subset with cells from the same bin. - df_tmp = df.loc[df.index.isin(indexes)] - # Change reference system for all cells in parallel. - nuclei_cm_fix = [] - with DistributedHandler(distributed_executor_address) as handler: - future = handler.batched_map( - process_this_index, - [index_row for index_row in df_tmp.iterrows()], - ) - nuclei_cm_fix.append(future) - # Average changed nuclear centroid over all cells - mean_nuclei_cm_fix = np.array(nuclei_cm_fix[0]).mean(axis=0) - # Store - df_agg.loc[b, "dna_dxc"] = mean_nuclei_cm_fix[0] - df_agg.loc[b, "dna_dyc"] = mean_nuclei_cm_fix[1] - df_agg.loc[b, "dna_dzc"] = mean_nuclei_cm_fix[2] - - else: - # Save nuclear displacement as zeros if no adjustment - # is requested. - df_agg["dna_dxc"] = 0 - df_agg["dna_dyc"] = 0 - df_agg["dna_dzc"] = 0 - - hlimits = [] - vlimits = [] - all_mem_contours = [] - all_dna_contours = [] - - # Loop over 3 different projections: xy=[0,1], xz=[0,2] and - # yz=[1,2] - for proj_id, projection in enumerate([[0, 1], [0, 2], [1, 2]]): - - # Get nuclear meshes and their 2D projections - # for 3 different projections,xy, xz and yz. - mem_contours, mem_meshes, mem_limits = get_contours_of_consecutive_reconstructions( - df = df_agg, - prefix = "mem_shcoeffs_L", - proj = projection, - lmax = 32 - ) - # Get cells meshes and their 2D projections - # for 3 different projections,xy, xz and yz. - dna_contours, dna_meshes, dna_limits = get_contours_of_consecutive_reconstructions( - df = df_agg, - prefix = "dna_shcoeffs_L", - proj = projection, - lmax = 32 - ) - - if proj_id == 0: - # Change the nuclear position relative to the cell - # in the reconstructed meshes when running the - # first projection - for b, mem_mesh, dna_mesh in zip(df_agg.index, mem_meshes, dna_meshes): - # Get nuclear mesh coordinates - dna_coords = vtk_to_numpy(dna_mesh.GetPoints().GetData()) - # Shift coordinates according averaged - # nuclear centroid relative to the cell - dna_coords[:,0] += df_agg.loc[b, "dna_dxc"] - dna_coords[:,1] += df_agg.loc[b, "dna_dyc"] - dna_coords[:,2] += df_agg.loc[b, "dna_dzc"] - dna_mesh.GetPoints().SetData(numpy_to_vtk(dna_coords)) - # Save meshes as vtk polydatas - shtools.save_polydata(mem_mesh, f"{save}/MEM_{mode}_{b:02d}.vtk") - shtools.save_polydata(dna_mesh, f"{save}/DNA_{mode}_{b:02d}.vtk") - # Save paths - df_paths.append({ - 'bin': b, - 'shapemode': mode, - 'memMeshPath': f"{save}/MEM_{mode}_{b:02d}.vtk", - 'dnaMeshPath': f"{save}/DNA_{mode}_{b:02d}.vtk" - }) - - all_mem_contours.append(mem_contours) - all_dna_contours.append(dna_contours) - - # Store bounds - xmin = np.min([lim[0] for lim in mem_limits]) - xmax = np.max([lim[1] for lim in mem_limits]) - ymin = np.min([lim[2] for lim in mem_limits]) - ymax = np.max([lim[3] for lim in mem_limits]) - zmin = np.min([lim[4] for lim in mem_limits]) - zmax = np.max([lim[5] for lim in mem_limits]) - - # Vertical and horizontal limits for plots - hlimits += [xmin, xmax, ymin, ymax] - vlimits += [ymin, ymax, zmin, zmax] - - # Dataframe with paths to be returned - df_paths = pd.DataFrame(df_paths) - - # Set limits for plots - if plot_limits is not None: - hmin, hmax, vmin, vmax = plot_limits - else: - hmin = np.min(hlimits) - hmax = np.max(hlimits) - vmin = np.min(vlimits) - vmax = np.max(vlimits) - offset = 0.05 * (hmax - hmin) - - # Plot 2D contours and animate accross bins - for projection, mem_contours, dna_contours in zip( - [[0, 1], [0, 2], [1, 2]], all_mem_contours, all_dna_contours - ): - - hcomp = projection[0] - vcomp = projection[1] - - fig, ax = plt.subplots(1, 1, figsize=(3, 3)) - plt.close() - ax.set_xlim(hmin - offset, hmax + offset) - ax.set_ylim(vmin - offset, vmax + offset) - ax.set_aspect("equal") - - # initial plot for cell - (mline,) = ax.plot([], [], lw=2, color="#F200FF" if "MEM" in mode else "#3AADA7") - # initial plot for nucleus - (dline,) = ax.plot([], [], lw=2, color="#3AADA7" if "DNA" in mode else "#F200FF") - - def animate(i): - ''' - Animates cell and nuclear contour accross bins - ''' - mct = mem_contours[i] - mx = mct[:, hcomp] - my = mct[:, vcomp] - - dct = dna_contours[i] - dx = dct[:, hcomp] - dy = dct[:, vcomp] - - hlabel = ["x", "y", "z"][[0, 1, 2].index(projection[0])] - vlabel = ["x", "y", "z"][[0, 1, 2].index(projection[1])] - # Shift 2D nuclear coordinates according averaged - # nuclear centroid relative to the cell - dx += df_agg.loc[i + 1, f"dna_d{hlabel}c"] - dy += df_agg.loc[i + 1, f"dna_d{vlabel}c"] - - mline.set_data(mx, my) - dline.set_data(dx, dy) - - return (mline, dline) - - # Generate animated GIF using scikit-image - anim = animation.FuncAnimation( - fig, animate, frames=len(mem_contours), interval=100, blit=True - ) - - try: - anim.save( - f"{save}/{mode}_{''.join(str(x) for x in projection)}.gif", - writer = "imagemagick", - fps = len(mem_contours) - ) - # Path of GIF files - df_paths['gifXYPath'] = f"{save}/{mode}_01.gif" - df_paths['gifXZPath'] = f"{save}/{mode}_02.gif" - df_paths['gifYZPath'] = f"{save}/{mode}_12.gif" - - except: - warnings.warn("Export to animated GIF has failed. Please check your imagemagick installation.") - - plt.close("all") - - return df_paths \ No newline at end of file diff --git a/cvapipe_analysis/steps/shapemode/dim_reduction.py b/cvapipe_analysis/steps/shapemode/dim_reduction.py deleted file mode 100644 index d3b746c..0000000 --- a/cvapipe_analysis/steps/shapemode/dim_reduction.py +++ /dev/null @@ -1,202 +0,0 @@ -import numpy as np -import pandas as pd -from pathlib import Path -import matplotlib.pyplot as plt -from sklearn.decomposition import PCA -from typing import List, Optional - -from cvapipe_analysis.tools import general - -class ShapeModesCalculator(general.DataProducer): - """ - Class for calculating shape modes. - - WARNING: All classes are assumed to know the whole - structure of directories inside the local_staging - folder and this is hard coded. Therefore, classes - may break if you move saved files away from the - places their are saved. - """ - - subfolder = 'shapemode/avgshape' - - def __init__(self, config): - super().__init__(config) - - def save(self): - save_as = self.get_rel_output_file_path_as_str(self.row) - return save_as - - def workflow(self): - return - - @staticmethod - def get_output_file_name(): - return None - - -class pPCA: - ''' - Simple class for store PCA objects with persistent feature names. - ''' - def __init__( - self, - pca: PCA, - features: List - ): - self.pca = pca - self.features = features - def get_pca(self): - return self.pca - def get_feature_names(self): - return self.features - -def pca_analysis( - df: pd.DataFrame, - feature_names: List, - prefix: str, - npcs_to_calc: int, - save: Optional[Path] = None -): - - """ - Performs principal component analysis on specific columns of - a pandas dataframe. - - Parameters - -------------------- - df: pandas df - Dataframe that contains the columns that should be used - as input for PCA. - features_names: list - List of column names. All columns must be present in df. - prefix: str - String to be appended to the column names that represent - the calculated principal components. - npcs_to_calc: int - dimenion of the dimensionality reduced dataset. - save: Path - Path to save the results. - - Returns - ------- - df: pandas df - Input dataset with new columns for the PCs calcukated - in by this function - pc_names: list - PCs column names - pca: pPCA - PCA objected fitted to the input data. This can be used - to perform inverse transfrom or transform new data. - """ - - # Get feature matrix - df_pca = df[feature_names] - matrix_of_features = df_pca.values.copy() - matrix_of_features_ids = df_pca.index - - # Fit and transform the data - pca = PCA(n_components=npcs_to_calc) - pca = pca.fit(matrix_of_features) - matrix_of_features_transform = pca.transform(matrix_of_features) - - pc_names = [f"{prefix}_PC{c}" for c in range(1, 1 + npcs_to_calc)] - - # Dataframe of transformed variable - df_trans = pd.DataFrame(data=matrix_of_features_transform, columns=pc_names) - df_trans.index = matrix_of_features_ids - - # Add PCs to the input dataframe - df = df.merge(df_trans[pc_names], how="outer", left_index=True, right_index=True) - - # Analysis of explained variance - df_dimred = {} - loading = pca.components_.T * np.sqrt(pca.explained_variance_) - for comp, pc_name in enumerate(pc_names): - load = loading[:, comp] - pc = [v for v in load] - apc = [v for v in np.abs(load)] - total = np.sum(apc) - cpc = [100 * v / total for v in apc] - df_dimred[pc_name] = pc - df_dimred[pc_name.replace("_PC", "_aPC")] = apc - df_dimred[pc_name.replace("_PC", "_cPC")] = cpc - - # Store results as a dataframe - df_dimred["features"] = df_pca.columns - df_dimred = pd.DataFrame(df_dimred) - df_dimred = df_dimred.set_index("features", drop=True) - - # Make plot of explained variance - plt.plot(100 * pca.explained_variance_ratio_[:npcs_to_calc], "-o") - title = "Cum. variance: (1+2) = {0}%, Total = {1}%".format( - int(100 * pca.explained_variance_ratio_[:2].sum()), - int(100 * pca.explained_variance_ratio_[:].sum()), - ) - plt.xlabel("Component", fontsize=18) - plt.ylabel("Explained variance (%)", fontsize=18) - plt.xticks( - ticks=np.arange(npcs_to_calc), - labels=np.arange(1, 1 + npcs_to_calc), - fontsize=14, - ) - plt.yticks(fontsize=14) - plt.title(title, fontsize=18) - plt.tight_layout() - plt.savefig(f"{save}.jpg") - plt.close("all") - - # Log feature importance along each PC - with open(f"{save}.txt", "w") as flog: - - for comp in range(npcs_to_calc): - - print( - f"\nExamplined variance by PC{comp+1} = {100*pca.explained_variance_ratio_[comp]:.1f}%", - file=flog, - ) - - # Feature importance is reported in 3 ways: - # _PC - raw loading - # _aPC - absolute loading - # _cPC - normalized cummulative loading - pc_name = pc_names[comp] - df_sorted = df_dimred.sort_values( - by=[pc_name.replace("_PC", "_aPC")], ascending=False - ) - pca_cum_contrib = np.cumsum( - df_sorted[pc_name.replace("_PC", "_aPC")].values - / df_sorted[pc_name.replace("_PC", "_aPC")].sum() - ) - pca_cum_thresh = np.abs(pca_cum_contrib - 0.80).argmin() - df_sorted = df_sorted.head(n=pca_cum_thresh + 1) - - print( - df_sorted[ - [ - pc_name, - pc_name.replace("_PC", "_aPC"), - pc_name.replace("_PC", "_cPC"), - ] - ].head(), - file=flog, - ) - - # Check wether all features are available - f = 'mem_shape_volume_lcc' - if f not in df.columns: - raise ValueError(f"Column {f} not found in the input dataframe. This\ - column is required to adjust the sign of PCs so that larger cells are\ - represent by positive values") - - # Adjust the sign of PCs so that larger cells are represent by positive values - for pcid, pc_name in enumerate(pc_names): - pearson = np.corrcoef(df.mem_shape_volume_lcc.values, df[pc_name].values) - if pearson[0, 1] < 0: - df[pc_name] *= -1 - pca.components_[pcid] *= -1 - - # Creates persistent PCA object - pca = pPCA(pca=pca, features=feature_names) - - return df, pc_names, pca diff --git a/cvapipe_analysis/steps/shapemode/outliers.py b/cvapipe_analysis/steps/shapemode/outliers.py deleted file mode 100644 index 0b2b444..0000000 --- a/cvapipe_analysis/steps/shapemode/outliers.py +++ /dev/null @@ -1,635 +0,0 @@ -import numpy as np -import matplotlib.pyplot as plt -from sklearn.utils import resample -from scipy.stats import gaussian_kde - -from .plotting import splot, oplot - - -def initial_parsing(df): - """ - TBD - """ - - # Load dataset - cells = df.copy().reset_index() - - # %% Check out columns, keep a couple - keepcolumns = [ - "CellId", - "structure_name", - "mem_roundness_surface_area_lcc", - "mem_shape_volume_lcc", - "dna_roundness_surface_area_lcc", - "dna_shape_volume_lcc", - "str_connectivity_cc", - "str_shape_volume", - "mem_position_depth_lcc", - "dna_position_depth_lcc" - ] - - cells = cells[keepcolumns] - - # %% Rename columns - cells = cells.rename( - columns={ - "mem_roundness_surface_area_lcc": "Cell surface area", - "mem_shape_volume_lcc": "Cell volume", - "dna_roundness_surface_area_lcc": "Nuclear surface area", - "dna_shape_volume_lcc": "Nuclear volume", - "str_connectivity_cc": "Number of pieces", - "str_shape_volume": "Structure volume", - "str_shape_volume_lcc": "Structure volume alt", - "mem_position_depth_lcc": "Cell height", - "dna_position_depth_lcc": "Nucleus height" - } - ) - - # %% Add a column - cells["Cytoplasmic volume"] = cells["Cell volume"] - cells["Nuclear volume"] - - return cells - -def outliers_removal(df, output_dir, log, detect_based_on_structure_features): - """ - TBD - """ - - # Load dataset - cells = initial_parsing(df=df) - - # %% Threshold for determing outliers - cell_dens_th_CN = 1e-20 # for cell-nucleus metrics across all cells - cell_dens_th_S = 1e-10 # for structure volume metrics - - # Remove outliers - - # %% Remove cells that lack a Structure Volume value - cells_ao = cells[["CellId", "structure_name"]].copy() - cells_ao["Outlier"] = "No" - CellIds_remove = cells.loc[cells["Structure volume"].isnull(), "CellId"].values - cells_ao.loc[cells_ao["CellId"].isin(CellIds_remove), "Outlier"] = "yes_missing_structure_volume" - cells = cells.drop(cells[cells["CellId"].isin(CellIds_remove)].index) - cells.reset_index(drop=True) - log.info( - f"Removing {len(CellIds_remove)} cells that lack a Structure Volume measurement value" - ) - log.info( - f"Shape of remaining dataframe: {cells.shape}" - ) - - # %% Feature set for cell and nuclear features - cellnuc_metrics = [ - "Cell surface area", - "Cell volume", - "Cell height", - "Nuclear surface area", - "Nuclear volume", - "Nucleus height", - "Cytoplasmic volume", - ] - cellnuc_abbs = [ - "Cell area", - "Cell vol", - "Cell height", - "Nuc area", - "Nuc vol", - "Nuc height", - "Cyto vol", - ] - - # %% All metrics including height - L = len(cellnuc_metrics) - pairs = np.zeros((int(L * (L - 1) / 2), 2)).astype(np.int) - i = 0 - for f1 in np.arange(L): - for f2 in np.arange(L): - if f2 > f1: - pairs[i, :] = [f1, f2] - i += 1 - - # %% The typical six scatter plots - xvec = [1, 1, 6, 1, 4, 6] - yvec = [4, 6, 4, 0, 3, 3] - pairs2 = np.stack((xvec, yvec)).T - - # %% Just one - xvec = [1] - yvec = [4] - - # %% Parameters - nbins = 100 - N = 10000 - fac = 1000 - Rounds = 5 - - # %% For all pairs compute densities - remove_cells = cells["CellId"].to_frame().copy() - for i, xy_pair in enumerate(pairs): - - metricX = cellnuc_metrics[xy_pair[0]] - metricY = cellnuc_metrics[xy_pair[1]] - log.info(f"{metricX} vs {metricY}") - - # data - x = cells[metricX].to_numpy() / fac - y = cells[metricY].to_numpy() / fac - - # density estimate, repeat because of probabilistic nature of density estimate - # used here - for r in np.arange(Rounds): - remove_cells[f"{metricX} vs {metricY}_{r}"] = np.nan - log.info(f"Round {r + 1} of {Rounds}") - rs = int(r) - xS, yS = resample( - x, y, replace=False, n_samples=np.amin([N, len(x)]), random_state=rs - ) - k = gaussian_kde(np.vstack([xS, yS])) - cell_dens = k(np.vstack([x.flatten(), y.flatten()])) - cell_dens = cell_dens / np.sum(cell_dens) - remove_cells.loc[ - remove_cells.index[np.arange(len(cell_dens))], - f"{metricX} vs {metricY}_{r}", - ] = cell_dens - - # %% Summarize across repeats - remove_cells_summary = cells["CellId"].to_frame().copy() - for i, xy_pair in enumerate(pairs): - metricX = cellnuc_metrics[xy_pair[0]] - metricY = cellnuc_metrics[xy_pair[1]] - log.info(f"{metricX} vs {metricY}") - metricX = cellnuc_metrics[xy_pair[0]] - metricY = cellnuc_metrics[xy_pair[1]] - filter_col = [ - col for col in remove_cells if col.startswith(f"{metricX} vs {metricY}") - ] - x = remove_cells[filter_col].to_numpy() - pos = np.argwhere(np.any(x < cell_dens_th_CN, axis=1)) - y = x[pos, :].squeeze() - - fig, axs = plt.subplots(1, 2, figsize=(16, 9)) - xr = np.log(x.flatten()) - xr = np.delete(xr, np.argwhere(np.isinf(xr))) - axs[0].hist(xr, bins=100) - axs[0].set_title("Histogram of cell probabilities (log scale)") - axs[0].set_yscale("log") - im = axs[1].imshow(np.log(y), aspect="auto") - plt.colorbar(im) - axs[1].set_title("Heatmap with low probability cells (log scale)") - - plot_save_path = f"{output_dir}/{metricX}_vs_{metricY}_cellswithlowprobs.png" - plt.savefig(plot_save_path, format="png", dpi=150) - plt.close("all") - - remove_cells_summary[f"{metricX} vs {metricY}"] = np.median(x, axis=1) - - # %% Identify cells to be removed - CellIds_remove_dict = {} - CellIds_remove = np.empty(0, dtype=int) - for i, xy_pair in enumerate(pairs): - metricX = cellnuc_metrics[xy_pair[0]] - metricY = cellnuc_metrics[xy_pair[1]] - CellIds_remove_dict[f"{metricX} vs {metricY}"] = np.argwhere( - remove_cells_summary[f"{metricX} vs {metricY}"].to_numpy() < cell_dens_th_CN - ) - CellIds_remove = np.union1d( - CellIds_remove, CellIds_remove_dict[f"{metricX} vs {metricY}"] - ) - log.info(len(CellIds_remove)) - - # %% Plot and remove outliers - plotname = "CellNucleus" - oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs2, - cells, - True, - output_dir, - f"{plotname}_6_org_fine", - 0.5, - [], - ) - oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs2, - cells, - True, - output_dir, - f"{plotname}_6_org_thick", - 2, - [], - ) - oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs2, - cells, - True, - output_dir, - f"{plotname}_6_outliers", - 2, - CellIds_remove_dict, - ) - oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs, - cells, - True, - output_dir, - f"{plotname}_21_org_fine", - 0.5, - [], - ) - oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs, - cells, - True, - output_dir, - f"{plotname}_21_org_thick", - 2, - [], - ) - oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs, - cells, - True, - output_dir, - f"{plotname}_21_outliers", - 2, - CellIds_remove_dict, - ) - log.info(cells.shape) - CellIds_remove = ( - cells.loc[cells.index[CellIds_remove], "CellId"].squeeze().to_numpy() - ) - cells_ao.loc[ - cells_ao["CellId"].isin(CellIds_remove), "Outlier" - ] = "yes_abnormal_cell_or_nuclear_metric" - cells = cells.drop(cells.index[cells["CellId"].isin(CellIds_remove)]) - log.info( - f"Removing {len(CellIds_remove)} cells due to abnormal cell or nuclear metric" - ) - log.info(cells.shape) - oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs2, - cells, - True, - output_dir, - f"{plotname}_6_clean_thick", - 2, - [], - ) - oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs2, - cells, - True, - output_dir, - f"{plotname}_6_clean_fine", - 0.5, - [], - ) - oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs, - cells, - True, - output_dir, - f"{plotname}_21_clean_thick", - 2, - [], - ) - oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs, - cells, - True, - output_dir, - f"{plotname}_21_clean_fine", - 0.5, - [], - ) - - # %% Feature sets for structures - selected_metrics = [ - "Cell volume", - "Cell surface area", - "Nuclear volume", - "Nuclear surface area", - ] - selected_metrics_abb = ["Cell Vol", "Cell Area", "Nuc Vol", "Nuc Area"] - selected_structures = [ - "LMNB1", - "ST6GAL1", - "TOMM20", - "SEC61B", - "ATP2A2", - "LAMP1", - "RAB5A", - "SLC25A17", - "TUBA1B", - "TJP1", - "NUP153", - "FBL", - "NPM1", - "SON", - ] - structure_metric = "Structure volume" - - # %% Parameters - N = 1000 - fac = 1000 - Rounds = 5 - - if detect_based_on_structure_features: - - # We may want to skip this part when running the test dataset - # or any small dataset that does not have enough cells per - # structure. - - # %% For all pairs compute densities - remove_cells = cells["CellId"].to_frame().copy() - for xm, metric in enumerate(selected_metrics): - for ys, struct in enumerate(selected_structures): - - # data - x = ( - cells.loc[cells["structure_name"] == struct, [metric]] - .squeeze() - .to_numpy() - / fac - ) - y = ( - cells.loc[cells["structure_name"] == struct, [structure_metric]] - .squeeze() - .to_numpy() - / fac - ) - - # density estimate, repeat because of probabilistic nature of density - # estimate used here - for r in np.arange(Rounds): - if ys == 0: - remove_cells[f"{metric} vs {structure_metric}_{r}"] = np.nan - rs = int(r) - xS, yS = resample( - x, y, replace=False, n_samples=np.amin([N, len(x)]), random_state=rs - ) - k = gaussian_kde(np.vstack([xS, yS])) - cell_dens = k(np.vstack([x.flatten(), y.flatten()])) - cell_dens = cell_dens / np.sum(cell_dens) - remove_cells.loc[ - cells["structure_name"] == struct, - f"{metric} vs {structure_metric}_{r}", - ] = cell_dens - - # remove_cells = pd.read_csv(data_root_extra / 'structures.csv') - - # %% Summarize across repeats - remove_cells_summary = cells["CellId"].to_frame().copy() - for xm, metric in enumerate(selected_metrics): - log.info(metric) - - filter_col = [ - col - for col in remove_cells - if col.startswith(f"{metric} vs {structure_metric}") - ] - x = remove_cells[filter_col].to_numpy() - pos = np.argwhere(np.any(x < cell_dens_th_S, axis=1)) - y = x[pos, :].squeeze() - - fig, axs = plt.subplots(1, 2, figsize=(16, 9)) - xr = np.log(x.flatten()) - xr = np.delete(xr, np.argwhere(np.isinf(xr))) - axs[0].hist(xr, bins=100) - axs[0].set_title("Histogram of cell probabilities (log scale)") - axs[0].set_yscale("log") - im = axs[1].imshow(np.log(y), aspect="auto") - plt.colorbar(im) - axs[1].set_title("Heatmap with low probability cells (log scale)") - - plot_save_path = ( - f"{output_dir}/{metric}_vs_{structure_metric}_cellswithlowprobs.png" - ) - plt.savefig(plot_save_path, format="png", dpi=150) - - remove_cells_summary[f"{metric} vs {structure_metric}"] = np.median(x, axis=1) - - # %% Identify cells to be removed - CellIds_remove_dict = {} - CellIds_remove = np.empty(0, dtype=int) - for xm, metric in enumerate(selected_metrics): - log.info(metric) - CellIds_remove_dict[f"{metric} vs {structure_metric}"] = np.argwhere( - remove_cells_summary[f"{metric} vs {structure_metric}"].to_numpy() - < cell_dens_th_S - ) - CellIds_remove = np.union1d( - CellIds_remove, CellIds_remove_dict[f"{metric} vs {structure_metric}"] - ) - log.info(len(CellIds_remove)) - - # %% Plot and remove outliers - plotname = "Structures" - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[0:7], - structure_metric, - cells, - True, - output_dir, - f"{plotname}_1_org_fine", - 0.5, - [], - ) - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[7:14], - structure_metric, - cells, - True, - output_dir, - f"{plotname}_2_org_fine", - 0.5, - [], - ) - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[0:7], - structure_metric, - cells, - True, - output_dir, - f"{plotname}_1_org_thick", - 2, - [], - ) - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[7:14], - structure_metric, - cells, - True, - output_dir, - f"{plotname}_2_org_thick", - 2, - [], - ) - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[0:7], - structure_metric, - cells, - True, - output_dir, - f"{plotname}_1_outliers", - 2, - CellIds_remove_dict, - ) - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[7:14], - structure_metric, - cells, - True, - output_dir, - f"{plotname}_2_outliers", - 2, - CellIds_remove_dict, - ) - log.info(cells.shape) - CellIds_remove = ( - cells.loc[cells.index[CellIds_remove], "CellId"].squeeze().to_numpy() - ) - cells_ao.loc[ - cells_ao["CellId"].isin(CellIds_remove), "Outlier" - ] = "yes_abnormal_structure_volume_metrics" - cells = cells.drop(cells.index[cells["CellId"].isin(CellIds_remove)]) - log.info(f"Removing {len(CellIds_remove)} cells due to structure volume metrics") - log.info(cells.shape) - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[0:7], - structure_metric, - cells, - True, - output_dir, - f"{plotname}_1_clean_fine", - 0.5, - [], - ) - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[7:14], - structure_metric, - cells, - True, - output_dir, - f"{plotname}_2_clean_fine", - 0.5, - [], - ) - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[0:7], - structure_metric, - cells, - True, - output_dir, - f"{plotname}_1_clean_thick", - 2, - [], - ) - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[7:14], - structure_metric, - cells, - True, - output_dir, - f"{plotname}_2_clean_thick", - 2, - [], - ) - - # %% Final diagnostic plot - cells = initial_parsing(df=df) - CellIds_remove_dict = {} - - for i, xy_pair in enumerate(pairs): - metricX = cellnuc_metrics[xy_pair[0]] - metricY = cellnuc_metrics[xy_pair[1]] - CellIds_remove_dict[f"{metricX} vs {metricY}"] = np.argwhere( - (cells_ao["Outlier"] == "yes_abnormal_cell_or_nuclear_metric").to_numpy() - ) - oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs2, - cells, - True, - output_dir, - "Check_cellnucleus", - 2, - CellIds_remove_dict, - ) - - CellIds_remove_dict = {} - for xm, metric in enumerate(selected_metrics): - CellIds_remove_dict[f"{metric} vs {structure_metric}"] = np.argwhere( - ( - (cells_ao["Outlier"] == "yes_abnormal_structure_volume_metrics") - | (cells_ao["Outlier"] == "yes_abnormal_cell_or_nuclear_metric") - ).to_numpy() - ) - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[0:7], - structure_metric, - cells, - True, - output_dir, - "Check_structures_1", - 2, - CellIds_remove_dict, - ) - splot( - selected_metrics, - selected_metrics_abb, - selected_structures[7:14], - structure_metric, - cells, - True, - output_dir, - "Check_structures_2", - 2, - CellIds_remove_dict, - ) - - cells_ao = cells_ao.set_index("CellId", drop=True) - - return cells_ao diff --git a/cvapipe_analysis/steps/shapemode/plotting.py b/cvapipe_analysis/steps/shapemode/plotting.py deleted file mode 100644 index e8e0423..0000000 --- a/cvapipe_analysis/steps/shapemode/plotting.py +++ /dev/null @@ -1,988 +0,0 @@ -import re -import warnings -import matplotlib -import numpy as np -import pandas as pd -from pathlib import Path -import matplotlib.pyplot as plt -from scipy import stats as scistats -from typing import List, Optional - -def dataset_summary_table( - df: pd.DataFrame, - levels: List, - factor: str, - rank_factor_by: Optional[str]=None, - save: Optional[Path] = None -): - - """ - Generates a summary table from a dataframe. - - Parameters - -------------------- - df: pandas df - Input dataframe to be summarized. - levels: list - List of column names. These names will be used to index - rows in the summary dataframe. - factor: str - Column name to stratify the data by. Each value of this - factor will be represented by one column in the summary - dataframe. - rank_factor_by: str - Column name to be used to sort the columns of the summary - dataframe by. If none is provided, then columns are - sorted in alphabetical order. - save: Path - Path to save the results. - - Returns - ------- - df_summary: pandas df - Summary dataframe - """ - - # Check if all variable are available - for col in levels+[factor]+[rank_factor_by]: - if (col is not None) and (col not in df.columns): - raise ValueError(f"Column {col} not found in the input dataframe.") - - # Fill missing data with NA - for level in levels: - df[level].fillna("NA", inplace=True) - - # Count number of cells - df_summary = df.groupby(levels+[factor]).size() - df_summary = df_summary.unstack(level=-1) - - if rank_factor_by is not None: - # Rank columns if a ranking variable is provided - order = ( - df.groupby([factor])[[rank_factor_by]] - .min() - .sort_values(by=rank_factor_by) - .index - ) - else: - # Uses alphabetical order - order = df[factor].unique() - order = sorted(order) - - # Rank dataframe - df_summary = df_summary[order] - - # Create a column for total number of cells - df_summary = pd.concat( - [ - df_summary, - pd.DataFrame( - [ - pd.Series( - dict( - zip( - df_summary.columns, - [df_summary[c].sum() for c in df_summary.columns], - ) - ), - name=("", "", "Total"), - ) - ] - ), - ], - axis=0, - ) - - # Create a row for order number - df_order = pd.DataFrame([ - pd.Series( - dict(zip(df_summary.columns, np.arange(1, 2 + len(order)))), - name=("", "", "Order"), - ) - ]) - df_summary = pd.concat([df_summary, df_order], axis=0) - - # Set pandas display properties - with pd.option_context("display.max_rows", None, "display.max_columns", None): - styler = ( - df_summary.style.set_table_styles( - [ - { - "selector": "th", - "props": [ - ("font-family", "Helvetica"), - ("font-size", "10pt"), - ("border", "1px solid gray"), - ], - } - ] - ) - .set_properties(**{"text-align": "left", "border": "1px solid gray"}) - #.bar(color="#D7BDE2") - .format(lambda x: f"{x if x>0 else ''}") - ) - - # Save view of the table as jpeg as well as csv - if save: - try: - import imgkit - from xvfbwrapper import Xvfb - vdisplay = Xvfb() - vdisplay.start() - imgkit.from_string(styler.render(), f"{save}.jpg") - vdisplay.stop() - except: - warnings.warn('Not abel to convert pandas dataframe to an image. Please check your imgkit and xvfbwrapper installations.') - pass - df_summary.to_csv(f"{save}_summary.csv") - - return df_summary - -def paired_correlation( - df: pd.DataFrame, - features: List, - save: Path, - units: Optional[List] = None, - off: Optional[float] = 0 -): - - """ - Create pairwise correlation between columns of a dataframe. - - Parameters - -------------------- - df: pandas df - Input dataframe that contains the features. - features: list - List of column names. Every feature in this list will - be plotted agains each other. - save: Path - Path to save the result - units: List - List of same length of features with a multiplication - factor for each feature. - save: Path - Path to save the results. - off: float - The plot axes will span off% to 100-off% of the data. - """ - - # Check if all variable are available - for col in features: - if col not in df.columns: - raise ValueError(f"Column {col} not found in the input dataframe.") - - npts = df.shape[0] - - cmap = plt.cm.get_cmap("tab10") - - # Drop rows for with one or more feature are NA - df = df.dropna(subset=features) - - if units is None: - units = np.ones(len(features)) - - # Check if all variable are available - if len(units) != len(features): - raise ValueError(f"Features and units should have same length.") - - # Clip the limits of the plot - prange = [] - for f, un in zip(features, units): - prange.append(np.percentile(un * df[f].values, [off, 100 - off])) - - # Create a grid of nfxnf - nf = len(features) - fig, axs = plt.subplots( - nf, - nf, - figsize=(2 * nf, 2 * nf), - sharex="col", - gridspec_kw={"hspace": 0.1, "wspace": 0.1}, - ) - # Make the plots - for f1id, (f1, un1) in enumerate(zip(features, units)): - - yrange = [] - for f2id, (f2, un2) in enumerate(zip(features, units)): - - ax = axs[f1id, f2id] - - y = un1 * df[f1].values - x = un2 * df[f2].values - - valids = np.where( - ( - (y > prange[f1id][0]) - & (y < prange[f1id][1]) - & (x > prange[f2id][0]) - & (x < prange[f2id][1]) - ) - ) - - # Add plots on lower triangle - if f2id < f1id: - xmin = x[valids].min() - xmax = x[valids].max() - ymin = y[valids].min() - ymax = y[valids].max() - yrange.append([ymin, ymax]) - ax.plot( - x[valids], y[valids], ".", markersize=1, color="black", alpha=0.1 - ) - ax.plot([xmin, xmax], [xmin, xmax], "--") - if f2id: - plt.setp(ax.get_yticklabels(), visible=False) - ax.tick_params(axis="y", which="both", length=0.0) - if f1id < nf - 1: - ax.tick_params(axis="x", which="both", length=0.0) - - # Add annotations on upper triangle - elif f2id > f1id: - plt.setp(ax.get_xticklabels(), visible=False) - plt.setp(ax.get_yticklabels(), visible=False) - ax.tick_params(axis="x", which="both", length=0.0) - ax.tick_params(axis="y", which="both", length=0.0) - pearson, p_pvalue = scistats.pearsonr(x, y) - spearman, s_pvalue = scistats.spearmanr(x, y) - ax.text( - 0.05, - 0.8, - f"Pearson: {pearson:.2f}", - size=10, - ha="left", - transform=ax.transAxes, - ) - ax.text( - 0.05, - 0.6, - f"P-value: {p_pvalue:.1E}", - size=10, - ha="left", - transform=ax.transAxes, - ) - ax.text( - 0.05, - 0.4, - f"Spearman: {spearman:.2f}", - size=10, - ha="left", - transform=ax.transAxes, - ) - ax.text( - 0.05, - 0.2, - f"P-value: {s_pvalue:.1E}", - size=10, - ha="left", - transform=ax.transAxes, - ) - - # Single variable distribution at diagonal - else: - ax.set_frame_on(False) - plt.setp(ax.get_yticklabels(), visible=False) - ax.tick_params(axis="y", which="both", length=0.0) - ax.hist( - x[valids], - bins=16, - density=True, - histtype="stepfilled", - color="white", - edgecolor="black", - label="Complete", - ) - ax.hist( - x[valids], - bins=16, - density=True, - histtype="stepfilled", - color=cmap(0), - alpha=0.2, - label="Incomplete", - ) - - if f1id == nf - 1: - ax.set_xlabel(f2, fontsize=7) - if not f2id and f1id: - ax.set_ylabel(f1, fontsize=7) - - if yrange: - ymin = np.min([ymin for (ymin, ymax) in yrange]) - ymax = np.max([ymax for (ymin, ymax) in yrange]) - for f2id, f2 in enumerate(features): - ax = axs[f1id, f2id] - if f2id < f1id: - ax.set_ylim(ymin, ymax) - - # Global annotation - fig.add_subplot(111, frameon=False) - plt.tick_params(labelcolor="none", top=False, bottom=False, left=False, right=False) - plt.title(f"Total number of points: {npts}", fontsize=24) - - # Save - plt.savefig(f"{save}.png", dpi=300) - plt.close("all") - - -# ------------------------------- -# NOT YET DOCUMENTED -# ------------------------------- - -# plot function -def splot( - selected_metrics, - selected_metrics_abb, - selected_structures, - structure_metric, - cells, - save_flag, - pic_root, - name, - markersize, - remove_cells, -): - - # Rows and columns - nrows = len(selected_metrics) - ncols = len(selected_structures) - - # Plotting parameters - fac = 1000 - ms = markersize - fs2 = np.round(np.interp(nrows * ncols, [6, 21, 50], [25, 15, 10])) - fs = np.round(fs2 * 2 / 3) - # lw2 = 1.5 - nbins = 100 - plt.rcParams.update({"font.size": fs}) - - # Plotting flags - # W = 500 - - # Time for a flexible scatterplot - w1 = 0.001 - w2 = 0.01 - w3 = 0.001 - h1 = 0.001 - h2 = 0.01 - h3 = 0.001 - xp = 0.1 - yp = 0.1 - xx = (1 - w1 - ((ncols - 1) * w2) - w3) / ncols - yy = (1 - h1 - ((nrows - 1) * h2) - h3) / nrows - xw = xx * xp - xx = xx * (1 - xp) - yw = yy * yp - yy = yy * (1 - yp) - - fig = plt.figure(figsize=(16, 9)) - - i = 0 - - for yi, metric in enumerate(selected_metrics): - for xi, struct in enumerate(selected_structures): - - pos = np.argwhere((cells["structure_name"] == struct).to_numpy()) - x = cells.loc[cells["structure_name"] == struct, [metric]].squeeze() - y = cells.loc[ - cells["structure_name"] == struct, [structure_metric] - ].squeeze() - # selcel = (cells['structure_name'] == struct).to_numpy() - # struct_pos = np.argwhere(selcel) - x = x.to_numpy() - y = y.to_numpy() - x = x / fac - y = y / fac - - # metricX = metric - # metricY = struct - abbX = selected_metrics_abb[yi] - abbY = selected_structures[xi] - - # select subplot - i = i + 1 - row = nrows - np.ceil(i / ncols) + 1 - row = row.astype(np.int64) - col = i % ncols - if col == 0: - col = ncols - print(f"{i}_{row}_{col}") - - # Main scatterplot - ax = fig.add_axes( - [ - w1 + ((col - 1) * (xw + xx + w2)) + xw, - h1 + ((row - 1) * (yw + yy + h2)) + yw, - xx, - yy, - ] - ) - ax.plot(x, y, "b.", markersize=ms) - if len(remove_cells) > 0: - cr = remove_cells[f"{metric} vs {structure_metric}"].astype(np.int) - _, i_cr, _ = np.intersect1d(pos, cr, return_indices=True) - if len(i_cr) > 0: - ax.plot(x[i_cr], y[i_cr], "r.", markersize=2 * ms) - - xticks = ax.get_xticks() - yticks = ax.get_yticks() - xlim = ax.get_xlim() - ylim = ax.get_ylim() - ax.set_xticklabels([]) - ax.set_yticklabels([]) - ax.grid() - - ax.text( - xlim[1], - ylim[1], - f"n= {len(x)}", - fontsize=fs, - verticalalignment="top", - horizontalalignment="right", - ) - if len(remove_cells) > 0: - ax.text( - xlim[0], - ylim[1], - f"n= {len(i_cr)}", - fontsize=fs, - verticalalignment="top", - horizontalalignment="left", - color=[1, 0, 0, 1], - ) - - # Bottom histogram - ax = fig.add_axes( - [ - w1 + ((col - 1) * (xw + xx + w2)) + xw, - h1 + ((row - 1) * (yw + yy + h2)), - xx, - yw, - ] - ) - ax.hist(x, bins=nbins, color=[0.5, 0.5, 0.5, 0.5]) - ylimBH = ax.get_ylim() - ax.set_xticks(xticks) - ax.set_yticks([]) - ax.set_yticklabels([]) - ax.set_xticklabels([]) - ax.set_xlim(left=xlim[0], right=xlim[1]) - ax.grid() - ax.invert_yaxis() - for n, val in enumerate(xticks): - if val >= xlim[0] and val <= xlim[1]: - if int(val) == val: - val = int(val) - else: - val = np.round(val, 2) - ax.text( - val, - ylimBH[0], - f"{val}", - fontsize=fs, - horizontalalignment="center", - verticalalignment="bottom", - color=[0.5, 0.5, 0.5, 0.5], - ) - - ax.text( - np.mean(xlim), - ylimBH[1], - f"{abbX}", - fontsize=fs2, - horizontalalignment="center", - verticalalignment="bottom", - ) - ax.axis("off") - - # Side histogram - ax = fig.add_axes( - [ - w1 + ((col - 1) * (xw + xx + w2)), - h1 + ((row - 1) * (yw + yy + h2)) + yw, - xw, - yy, - ] - ) - ax.hist(y, bins=nbins, color=[0.5, 0.5, 0.5, 0.5], orientation="horizontal") - xlimSH = ax.get_xlim() - ax.set_yticks(yticks) - ax.set_xticks([]) - ax.set_xticklabels([]) - ax.set_yticklabels([]) - ax.set_ylim(bottom=ylim[0], top=ylim[1]) - ax.grid() - ax.invert_xaxis() - for n, val in enumerate(yticks): - if val >= ylim[0] and val <= ylim[1]: - if int(val) == val: - val = int(val) - else: - val = np.round(val, 2) - ax.text( - xlimSH[0], - val, - f"{val}", - fontsize=fs, - horizontalalignment="left", - verticalalignment="center", - color=[0.5, 0.5, 0.5, 0.5], - ) - - ax.text( - xlimSH[1], - np.mean(ylim), - f"{abbY}", - fontsize=fs2, - horizontalalignment="left", - verticalalignment="center", - rotation=90, - ) - ax.axis("off") - - if save_flag: - plot_save_path = pic_root / f"{name}.png" - plt.savefig(plot_save_path, format="png", dpi=150) - plt.close("all") - else: - plt.show() - - -# function defintion -def oplot( - cellnuc_metrics, - cellnuc_abbs, - pairs, - cells, - save_flag, - pic_root, - name, - markersize, - remove_cells, -): - - # Selecting number of pairs - no_of_pairs, _ = pairs.shape - nrows = np.floor(np.sqrt(2 / 3 * no_of_pairs)) - if nrows == 0: - nrows = 1 - ncols = np.floor(nrows * 3 / 2) - while nrows * ncols < no_of_pairs: - ncols += 1 - - # Plotting parameters - fac = 1000 - ms = markersize - fs2 = np.round(np.interp(nrows * ncols, [6, 21, 50], [25, 12, 8])) - fs = np.round(fs2 * 2 / 3) - # lw2 = 1.5 - nbins = 100 - plt.rcParams.update({"font.size": fs}) - - # Plotting flags - # W = 500 - - # Time for a flexible scatterplot - w1 = 0.001 - w2 = 0.01 - w3 = 0.001 - h1 = 0.001 - h2 = 0.01 - h3 = 0.001 - xp = 0.1 - yp = 0.1 - xx = (1 - w1 - ((ncols - 1) * w2) - w3) / ncols - yy = (1 - h1 - ((nrows - 1) * h2) - h3) / nrows - xw = xx * xp - xx = xx * (1 - xp) - yw = yy * yp - yy = yy * (1 - yp) - - fig = plt.figure(figsize=(16, 9)) - - for i, xy_pair in enumerate(pairs): - - print(i) - - metricX = cellnuc_metrics[xy_pair[0]] - metricY = cellnuc_metrics[xy_pair[1]] - abbX = cellnuc_abbs[xy_pair[0]] - abbY = cellnuc_abbs[xy_pair[1]] - - # data - x = cells[metricX].to_numpy() / fac - y = cells[metricY].to_numpy() / fac - - # select subplot - row = nrows - np.ceil((i + 1) / ncols) + 1 - row = row.astype(np.int64) - col = (i + 1) % ncols - if col == 0: - col = ncols - col = col.astype(np.int64) - print(f"{i}_{row}_{col}") - - # Main scatterplot - ax = fig.add_axes( - [ - w1 + ((col - 1) * (xw + xx + w2)) + xw, - h1 + ((row - 1) * (yw + yy + h2)) + yw, - xx, - yy, - ] - ) - ax.plot(x, y, "b.", markersize=ms) - - if len(remove_cells) > 0: - try: - cr = remove_cells[f"{metricX} vs {metricY}"].astype(np.int) - except: - cr = remove_cells[f"{metricY} vs {metricX}"].astype(np.int) - ax.plot(x[cr], y[cr], "r.", markersize=2 * ms) - - xticks = ax.get_xticks() - yticks = ax.get_yticks() - xlim = ax.get_xlim() - ylim = ax.get_ylim() - ax.set_xticklabels([]) - ax.set_yticklabels([]) - ax.grid() - - ax.text( - xlim[1], - ylim[1], - f"n= {len(x)}", - fontsize=fs, - verticalalignment="top", - horizontalalignment="right", - color=[0.75, 0.75, 0.75, 0.75], - ) - if len(remove_cells) > 0: - ax.text( - xlim[0], - ylim[1], - f"n= {len(cr)}", - fontsize=fs, - verticalalignment="top", - horizontalalignment="left", - color=[1, 0, 0, 1], - ) - - # Bottom histogram - ax = fig.add_axes( - [ - w1 + ((col - 1) * (xw + xx + w2)) + xw, - h1 + ((row - 1) * (yw + yy + h2)), - xx, - yw, - ] - ) - ax.hist(x, bins=nbins, color=[0.5, 0.5, 0.5, 0.5]) - ylimBH = ax.get_ylim() - ax.set_xticks(xticks) - ax.set_yticks([]) - ax.set_yticklabels([]) - ax.set_xticklabels([]) - ax.set_xlim(left=xlim[0], right=xlim[1]) - ax.grid() - ax.invert_yaxis() - for n, val in enumerate(xticks): - if val >= xlim[0] and val <= xlim[1]: - if int(val) == val: - val = int(val) - else: - val = np.round(val, 2) - ax.text( - val, - ylimBH[0], - f"{val}", - fontsize=fs, - horizontalalignment="center", - verticalalignment="bottom", - color=[0.75, 0.75, 0.75, 0.75], - ) - - ax.text( - np.mean(xlim), - ylimBH[1], - f"{abbX}", - fontsize=fs2, - horizontalalignment="center", - verticalalignment="bottom", - ) - ax.axis("off") - - # Side histogram - ax = fig.add_axes( - [ - w1 + ((col - 1) * (xw + xx + w2)), - h1 + ((row - 1) * (yw + yy + h2)) + yw, - xw, - yy, - ] - ) - ax.hist(y, bins=nbins, color=[0.5, 0.5, 0.5, 0.5], orientation="horizontal") - xlimSH = ax.get_xlim() - ax.set_yticks(yticks) - ax.set_xticks([]) - ax.set_xticklabels([]) - ax.set_yticklabels([]) - ax.set_ylim(bottom=ylim[0], top=ylim[1]) - ax.grid() - ax.invert_xaxis() - for n, val in enumerate(yticks): - if val >= ylim[0] and val <= ylim[1]: - if int(val) == val: - val = int(val) - else: - val = np.round(val, 2) - ax.text( - xlimSH[0], - val, - f"{val}", - fontsize=fs, - horizontalalignment="left", - verticalalignment="center", - color=[0.75, 0.75, 0.75, 0.75], - ) - - ax.text( - xlimSH[1], - np.mean(ylim), - f"{abbY}", - fontsize=fs2, - horizontalalignment="left", - verticalalignment="center", - rotation=90, - ) - ax.axis("off") - - if save_flag: - plot_save_path = pic_root / f"{name}.png" - plt.savefig(plot_save_path, format="png", dpi=150) - plt.close("all") - else: - plt.show() - -def vertical_distributions( - df_input, - yvar, - ylabel, - units, - factor, - sortby, - function, - clip=None, - force_float=False, - colorby=None, - color_fix=None, - references=None, - highlight=None, - top_text=False, - use_std=False, - save=None, -): - - # Preparation - - variables = np.unique([factor, yvar, sortby[0], colorby]) - - df = df_input[variables].copy() - - df = df.dropna(subset=variables) - - # Apply function - if function is not None: - df[yvar] = function(df[yvar]) - df[yvar] = units * df[yvar] - - if clip is not None: - pcts = np.percentile(df[yvar], clip) - - if force_float: - df = df.astype({sortby[0]: "float"}) - - df["jitter"] = np.random.normal(size=df.shape[0]) - - xmin = df.jitter.min() - xmax = df.jitter.max() - - nlevels = len(df[factor].unique()) - - fig, axs = plt.subplots( - 1, nlevels, figsize=(0.7 * nlevels, 6), gridspec_kw={"wspace": 0.0} - ) - - sorter = ( - df[[factor, sortby[0]]] - .groupby(factor) - .agg(sortby[1]) - .sort_values(by=sortby[0], ascending=True) - .index.tolist() - ) - - if use_std: - operation = np.mean - else: - operation = np.median - - # Reference - if references is not None: - reference_value = operation(df.loc[df[factor].isin(references), yvar].values) - - # Colors - if colorby is not None: - color_values = list(df[colorby].unique()) - color_values_parse = [re.sub("[^\d\.]", "", cv) for cv in color_values] - color_values = [color_values[i] for i in np.argsort(color_values_parse)] - ncolors = len(color_values) - print(f"Number of colors: {ncolors}") - if ncolors < 10: - color_mode = "discrete" - cmap = plt.cm.get_cmap("Dark2") - else: - color_mode = "continuous" - cmap = plt.cm.get_cmap("jet") - - for ax, fac in enumerate(sorter): - df_fac = df.loc[df[factor] == fac] - # axs[ax].axis('off') - axs[ax].spines["top"].set_visible(False) - axs[ax].spines["right"].set_visible(False) - if ax: - axs[ax].spines["left"].set_visible(False) - axs[ax].set_yticks([]) - axs[ax].set_xticks([]) - if colorby is not None: - if color_mode == "discrete": - for c, cvalue in enumerate(color_values): - df_color = df_fac.loc[df_fac[colorby] == cvalue] - nsamples = df_color.shape[0] - if nsamples > 0: - color = cmap(c) - if color_fix is not None: - if cvalue in color_fix: - color = color_fix[cvalue] - color = [color] * nsamples - axs[ax].scatter( - df_color.jitter, df_color[yvar], s=1, alpha=0.2, c=color - ) - if color_mode == "continuous": - for c, cvalue in enumerate(color_values): - df_color = df_fac.loc[df_fac[colorby] == cvalue] - nsamples = df_color.shape[0] - if nsamples > 0: - color = cmap(c / (ncolors - 1)) - if color_fix is not None: - if cvalue in color_fix: - color = color_fix[cvalue] - color = [color] * nsamples - axs[ax].scatter( - df_color.jitter, df_color[yvar], s=1, alpha=0.2, c=color - ) - else: - axs[ax].scatter(df_fac.jitter, df_fac[yvar], s=1, alpha=0.2, c="#6495ED") - ymid = operation(df_fac[yvar].values) - y_qi, y_q1, y_q3, y_qs = np.percentile(df_fac[yvar].values, [10, 25, 75, 90]) - - if use_std: - y_qi = ymid - 2 * df_fac[yvar].values.std() - y_q1 = ymid - df_fac[yvar].values.std() - y_q3 = ymid + df_fac[yvar].values.std() - y_qs = ymid + 2 * df_fac[yvar].values.std() - - if fac in references: - print(f"Data clips: {pcts[0]:.2f} - {pcts[1]:.2f}") - print( - f"[{fac}] - Qi: {y_qi:.2f}, Q1: {y_q1:0.2f}, Q3: {y_q3:0.2f}, Qs: {y_qs:.2f}" - ) - - axs[ax].scatter(0, ymid, s=30, c="k") - deltax = 0.25 * (xmax - xmin) - axs[ax].plot([-deltax, deltax], [y_qi, y_qi], color="k", alpha=0.5, linewidth=3) - axs[ax].plot([-deltax, deltax], [y_q1, y_q1], color="k", alpha=0.8, linewidth=6) - axs[ax].plot([-deltax, deltax], [y_q3, y_q3], color="k", alpha=0.8, linewidth=6) - axs[ax].plot([-deltax, deltax], [y_qs, y_qs], color="k", alpha=0.5, linewidth=3) - - color = "black" - if highlight is not None: - if (y_q3 < reference_value) | (y_q1 > reference_value): - color = "red" - axs[ax].set_xlabel( - fac, - rotation=90, - fontdict={"size": 18, "color": color}, - labelpad=5, - ha="center", - ) - - if top_text: - toptext = df_fac[sortby[0]].mean() - axs[ax].text( - 0.5, - 1.00, - f"{toptext:.2f}", - size=10, - ha="center", - transform=axs[ax].transAxes, - ) - - axs[ax].set_xlim(xmin, xmax) - if clip: - axs[ax].set_ylim(pcts) - - if color_mode == "discrete": - legend_elements = [] - for c, cvalue in enumerate(color_values): - legend_elements.append( - matplotlib.patches.Patch( - facecolor=cmap(c) if cvalue not in color_fix else color_fix[cvalue], - edgecolor="k", - label=cvalue, - ) - ) - if references is not None: - legend_elements.append( - matplotlib.lines.Line2D( - [0], - [0], - linestyle="--", - color="k", - lw=4, - label=f'Reference:\n{",".join(references)}', - ) - ) - axs[-1].legend( - handles=legend_elements, - loc="center left", - bbox_to_anchor=(1, 0.5), - title=colorby, - ) - - if references is not None: - axs[-1].add_artist( - matplotlib.patches.ConnectionPatch( - xyA=(xmin, reference_value), - xyB=(xmax, reference_value), - coordsA=axs[0].transData, - coordsB=axs[-1].transData, - linestyle="--", - linewidth=2, - color="k", - ) - ) - - fig.add_subplot(111, frameon=False) - plt.tick_params(labelcolor="none", top=False, bottom=False, left=False, right=False) - plt.ylabel(ylabel, fontsize=24, labelpad=10) - - if save is not None: - fig.savefig(save, bbox_inches="tight", format="png", dpi=300) - plt.show() - - try: - df_agg = df[[factor, sortby[0]]].groupby(factor).agg(["mean", "min"]) - df_agg = df_agg.sort_values(by=[(sortby[0], "mean")]) - display(df_agg) - except: - pass diff --git a/cvapipe_analysis/steps/shapemode/shapemode.py b/cvapipe_analysis/steps/shapemode/shapemode.py index 5a7d973..16ec803 100644 --- a/cvapipe_analysis/steps/shapemode/shapemode.py +++ b/cvapipe_analysis/steps/shapemode/shapemode.py @@ -6,7 +6,7 @@ from typing import Dict, List, Optional, Union from datastep import Step, log_run_params -from cvapipe_analysis.tools import io, general +from ...tools import io, general from .shapemode_tools import ShapeModeCalculator log = logging.getLogger(__name__) @@ -21,19 +21,26 @@ def __init__( super().__init__(direct_upstream_tasks=direct_upstream_tasks, config=config) @log_run_params - def run(self, debug: bool=False, **kwargs): + def run( + self, + staging: Union[str, Path], + verbose: Optional[bool]=False, + distribute: Optional[bool]=False, + **kwargs): + + step_dir = Path(staging) / self.step_name - with general.configuration(self.step_local_staging_dir) as control: + with general.configuration(step_dir) as control: + # control.create_step_subdirs(step_dir, ["pca", "avgshape"]) + device = io.LocalStagingIO(control) df = device.load_step_manifest("preprocessing") log.info(f"Manifest: {df.shape}") - for folder in ["pca", "avgshape"]: - save_dir = self.step_local_staging_dir/folder - save_dir.mkdir(parents=True, exist_ok=True) - calculator = ShapeModeCalculator(control) + if verbose: + calculator.set_verbose_mode_on() calculator.set_data(df) calculator.execute() diff --git a/cvapipe_analysis/steps/shapemode/shapemode_tools.py b/cvapipe_analysis/steps/shapemode/shapemode_tools.py index e2eadd3..4cbbf45 100644 --- a/cvapipe_analysis/steps/shapemode/shapemode_tools.py +++ b/cvapipe_analysis/steps/shapemode/shapemode_tools.py @@ -6,7 +6,7 @@ from vtk.util.numpy_support import numpy_to_vtk as np2vtk from vtk.util.numpy_support import vtk_to_numpy as vtk2np -from cvapipe_analysis.tools import io, shapespace, plotting, viz +from ...tools import io, shapespace, plotting, viz class ShapeModeCalculator(io.DataProducer): """ @@ -21,9 +21,11 @@ class ShapeModeCalculator(io.DataProducer): def __init__(self, control): super().__init__(control) + self._use_vtk_for_intersection = True self.space = shapespace.ShapeSpace(control) self.plot_maker_sm = plotting.ShapeModePlotMaker(control) self.plot_maker_sp = plotting.ShapeSpacePlotMaker(control) + control.create_step_subdirs(control.get_staging(), ["shapemode/pca", "shapemode/avgshape"]) def set_data(self, df): self.df = df @@ -38,24 +40,34 @@ def execute(self): self.workflow() computed = True except Exception as ex: - print(f"\n>>>{ex}\n") + self.print(f"\n>>>{ex}\n") path_to_output_file = None self.status(None, path_to_output_file, computed) return path_to_output_file def workflow(self): + self.print("Creating shape space...") + self.space.verbose_mode(self._verbose) self.space.execute(self.df) - self.space.save_summary("shapemode/summary.html") + try: + self.space.save_summary("shapemode/summary.html") + except Exception as ex: + self.print(f"Failed while saving summary: {ex}. Skipping this step.") + pass + self.print("Making initial plots...") self.plot_maker_sp.save_feature_importance(self.space) self.plot_maker_sp.plot_explained_variance(self.space) self.plot_maker_sp.plot_pairwise_correlations(self.space) self.plot_maker_sp.execute(display=False) - + self.print("Getting SHE for shape modes...") self.compute_shcoeffs_for_all_shape_modes() + self.print("Correcting alias location based on reference...") self.compute_displacement_vector_relative_to_reference() - print("Generating 3D meshes. This might take some time...") + self.print("Generating 3D meshes. This might take some time...") self.recontruct_meshes() + self.print("Generating animated contours...") self.generate_and_save_animated_2d_contours() + self.print("Generating GIFs...") self.plot_maker_sm.combine_and_save_animated_gifs() return @@ -67,6 +79,9 @@ def save(self): # For consistency. return + def use_vtk_for_intersection(self, use_vtk=True): + self._use_vtk_for_intersection = use_vtk + def get_coordinates_matrix(self, coords, comp): '''Coords has shape (N,). Creates a matrix of shape (N,M), where M is the reduced dimension. comp is an @@ -154,7 +169,8 @@ def generate_and_save_animated_2d_contours(self): swap = self.control.swapxy_on_zproj() abs_path_avgshape = self.control.get_staging()/f"shapemode/avgshape" for sm, meshes in tqdm(self.meshes.items(), total=len(self.meshes)): - projs = viz.MeshToolKit.get_2d_contours(meshes, swap) + projs = viz.MeshToolKit.get_2d_contours( + meshes, swap, use_vtk=self._use_vtk_for_intersection, verbose=self._verbose) for proj, contours in projs.items(): fname = f"{abs_path_avgshape}/{sm}_{proj}.gif" viz.MeshToolKit.animate_contours(self.control, contours, save=fname) diff --git a/cvapipe_analysis/steps/stereotypy/stereotypy.py b/cvapipe_analysis/steps/stereotypy/stereotypy.py index 6f5b185..cdf1c7a 100644 --- a/cvapipe_analysis/steps/stereotypy/stereotypy.py +++ b/cvapipe_analysis/steps/stereotypy/stereotypy.py @@ -11,8 +11,8 @@ import pandas as pd from tqdm import tqdm -from cvapipe_analysis.tools import io, general, cluster, shapespace, plotting from .stereotypy_tools import StereotypyCalculator +from ...tools import io, general, cluster, shapespace, plotting log = logging.getLogger(__name__) @@ -28,15 +28,16 @@ def __init__( @log_run_params def run( self, - distribute: Optional[bool] = False, - **kwargs - ): + staging: Union[str, Path], + verbose: Optional[bool]=False, + distribute: Optional[bool]=False, + **kwargs): + + step_dir = Path(staging) / self.step_name - with general.configuration(self.step_local_staging_dir) as control: + with general.configuration(step_dir) as control: - for folder in ['values', 'plots']: - save_dir = self.step_local_staging_dir / folder - save_dir.mkdir(parents=True, exist_ok=True) + control.create_step_subdirs(step_dir, ["values", "plots"]) device = io.LocalStagingIO(control) df = device.load_step_manifest("preprocessing") @@ -49,7 +50,8 @@ def run( if len(control.get_map_points()) > 1: variables.update({"shape_mode": ["NdSphere"], "mpId": [control.get_center_map_point_index()]}) df_sphere = space.get_aggregated_df(variables, include_cellIds=False) - df_agg = df_agg.append(df_sphere, ignore_index=True) + df_agg = pd.concat([df_agg, df_sphere]) + df_agg = df_agg.reset_index(drop=True) df_agg = df_agg.drop(columns=["structure"]).drop_duplicates().reset_index(drop=True) log.info(f"Generating plots...") diff --git a/cvapipe_analysis/steps/validation/__init__.py b/cvapipe_analysis/steps/validation/__init__.py new file mode 100644 index 0000000..5801e30 --- /dev/null +++ b/cvapipe_analysis/steps/validation/__init__.py @@ -0,0 +1,3 @@ +from .validation import Validation # noqa: F401 + +__all__ = ["Validation"] \ No newline at end of file diff --git a/cvapipe_analysis/steps/validation/validation.py b/cvapipe_analysis/steps/validation/validation.py new file mode 100644 index 0000000..1a2d7be --- /dev/null +++ b/cvapipe_analysis/steps/validation/validation.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import os +import logging +from pathlib import Path +from datastep import Step, log_run_params +from typing import Dict, List, Optional, Union + +import concurrent +from .validation_tools import Validator +from ...tools import io, general, cluster, plotting + +log = logging.getLogger(__name__) + +class Validation(Step): + def __init__( + self, + direct_upstream_tasks: List["Step"] = [], + config: Optional[Union[str, Path, Dict[str, str]]] = None, + ): + super().__init__(direct_upstream_tasks=direct_upstream_tasks, config=config) + + @log_run_params + def run( + self, + staging: Union[str, Path], + verbose: Optional[bool]=False, + distribute: Optional[bool]=False, + **kwargs): + + step_dir = Path(staging) / self.step_name + + with general.configuration(step_dir) as control: + + control.create_step_subdirs(step_dir, ["output"]) + + device = io.LocalStagingIO(control) + df = device.load_step_manifest("preprocessing") + log.info(f"Manifest: {df.shape}") + + df = df.sample(n=300, random_state=42) + + if distribute: + # TBD + return None + + validator = Validator(control) + if verbose: + validator.set_verbose_mode_on() + with concurrent.futures.ProcessPoolExecutor(control.get_ncores()) as executor: + executor.map(validator.execute, [row for _,row in df.iterrows()]) + + log.info(f"Loading results...") + df_error = validator.load_results_in_single_dataframe() + + pmaker = plotting.ValidationPlotMaker(control) + pmaker.set_dataframe(df_error) + pmaker.execute(display=False) + + df_error.to_csv(step_dir/"rec_error.csv", index=False) + + return diff --git a/cvapipe_analysis/steps/validation/validation_tools.py b/cvapipe_analysis/steps/validation/validation_tools.py new file mode 100644 index 0000000..4072884 --- /dev/null +++ b/cvapipe_analysis/steps/validation/validation_tools.py @@ -0,0 +1,93 @@ +import argparse +import concurrent +import numpy as np +import pandas as pd +from aicsshparam import shparam, shtools +from skimage import measure as skmeasure +from skimage import morphology as skmorpho + +from cvapipe_analysis.tools import io, general, controller, viz + +class Validator(io.DataProducer): + """ + Class for feature extraction. + + WARNING: All classes are assumed to know the whole + structure of directories inside the local_staging + folder and this is hard coded. Therefore, classes + may break if you move saved files away from the + places their are saved. + """ + + def __init__(self, control): + super().__init__(control) + self.subfolder = "validation/output" + + def workflow(self): + self.print(f"Starting validation on cell {self.row.name}...") + self.load_single_cell_data() + self.print(f"Calculating reconstruction error...") + self.compute_reconstruction_error() + self.print("Done.") + return + + def get_output_file_name(self): + return f"{self.row.name}.csv" + + def save(self): + save_as = self.get_output_file_path() + self.df_err.to_csv(save_as, index=False) + return save_as + + def compute_reconstruction_error(self): + self.df_err = pd.DataFrame([]) + for alias in self.control.get_aliases_for_feature_extraction(): + if self.control.should_calculate_shcoeffs(alias): + df_tmp = self.compute_reconstruction_error_for_alias(alias) + self.df_err = self.df_err.append(df_tmp, ignore_index=True) + return + + def compute_reconstruction_error_for_alias(self, alias): + df_err = [] + channel = self.control.get_channel_from_alias(alias) + chId = self.channels.index(channel) + for lrec in range(2, 2*self.control.get_lmax()): + (_, grid_rec), (_, mesh, grid, _) = shparam.get_shcoeffs( + image=self.data[chId], + lmax=lrec, + sigma=self.control.get_sigma(alias), + alignment_2d=False + ) + mesh_rec = shtools.get_reconstruction_from_grid(grid_rec) + d12, d21 = viz.MeshToolKit.get_meshes_distance(mesh, mesh_rec) + d12 = np.median(d12) + d21 = np.median(d21) + df_err.append({ + "lrec": lrec, + "alias": alias, + "d12": d12, + "d21": d21, + # Hard coding pixel size for now + "error": 0.5*(d12+d21)*0.108, + "CellId": self.row.name + }) + df_err = pd.DataFrame(df_err) + return df_err + +if __name__ == "__main__": + + parser = argparse.ArgumentParser(description="Batch single cell feature extraction.") + parser.add_argument("--staging", help="Path to staging.", required=True) + parser.add_argument("--csv", help="Path to the dataframe.", required=True) + args = vars(parser.parse_args()) + + config = general.load_config_file(args["staging"]) + control = controller.Controller(config) + + df = pd.read_csv(args["csv"], index_col="CellId") + print(f"Processing dataframe of shape {df.shape}") + + validator = Validator(control) + with concurrent.futures.ProcessPoolExecutor(control.get_ncores()) as executor: + executor.map(validator.execute, [row for _, row in df.iterrows()]) + diff --git a/cvapipe_analysis/tests/__init__.py b/cvapipe_analysis/tests/__init__.py index 9601cf1..4a868d9 100644 --- a/cvapipe_analysis/tests/__init__.py +++ b/cvapipe_analysis/tests/__init__.py @@ -1,3 +1,13 @@ # -*- coding: utf-8 -*- -"""Unit test package for cvapipe_analysis.""" +"""Top-level package for aics-shparam.""" + +__author__ = "Matheus Viana" +__email__ = "matheus.viana@alleninstitute.org" +# Do not edit this string manually, always use bumpversion +# Details in CONTRIBUTING.md +__version__ = "0.1.9" + + +def get_module_version(): + return __version__ \ No newline at end of file diff --git a/cvapipe_analysis/tests/conftest.py b/cvapipe_analysis/tests/conftest.py deleted file mode 100644 index 22a454a..0000000 --- a/cvapipe_analysis/tests/conftest.py +++ /dev/null @@ -1,11 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -from pathlib import Path - -import pytest - - -@pytest.fixture -def data_dir() -> Path: - return Path(__file__).parent / "data" diff --git a/cvapipe_analysis/tests/test_multires_struct_compare.py b/cvapipe_analysis/tests/test_multires_struct_compare.py deleted file mode 100644 index 07f844d..0000000 --- a/cvapipe_analysis/tests/test_multires_struct_compare.py +++ /dev/null @@ -1,78 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -from pathlib import Path - -import pandas as pd - -from cvapipe_analysis.steps import MultiResStructCompare - -EXPECTED_COLUMNS = [ - "Pearson Correlation", - "Resolution (micrometers)", -] - -from cvapipe_analysis.steps.multi_res_struct_compare.constants import ( - DatasetFieldsMorphed, - DatasetFieldsAverageMorphed, -) - - -def test_morphed_cells_run(data_dir): - - multiresstructcompare = MultiResStructCompare() - - output = multiresstructcompare.run( - input_csv_loc=Path( - "/allen/aics/modeling/ritvik/projects/cvapipe/" - + "FinalMorphedStereotypyDatasetPC1.csv" - ), - max_rows=10, - ) - - fig_plus_data_manifest = pd.read_csv(output) - similarity_score_manifest = pd.read_csv(fig_plus_data_manifest["path"][0]) - - # Check pearson corr and res columns - assert all( - expected_col in similarity_score_manifest.columns - for expected_col in [ - *EXPECTED_COLUMNS, - DatasetFieldsMorphed.StructureName1, - DatasetFieldsMorphed.StructureName2, - DatasetFieldsMorphed.Bin1, - DatasetFieldsMorphed.Bin2, - DatasetFieldsMorphed.CellId1, - DatasetFieldsMorphed.CellId2, - DatasetFieldsMorphed.SourceReadPath1, - DatasetFieldsMorphed.SourceReadPath2, - ] - ) - - -def test_avg_morphed_cell_run(data_dir): - - multiresstructcompare = MultiResStructCompare() - output = multiresstructcompare.run( - input_5d_stack=Path( - "/allen/aics/assay-dev/MicroscopyOtherData/Viana/projects/" - + "assay-dev-cytoparam/avgcell/DNA_MEM_PC1_seg_avg.tif" - ), - max_rows=10, - ) - - fig_plus_data_manifest = pd.read_csv(output) - similarity_score_manifest = pd.read_csv(fig_plus_data_manifest["path"][0]) - - # Check expected columns - assert all( - expected_col in similarity_score_manifest.columns - for expected_col in [ - *EXPECTED_COLUMNS, - DatasetFieldsAverageMorphed.StructureIndex1, - DatasetFieldsAverageMorphed.StructureIndex2, - DatasetFieldsAverageMorphed.StructureName1, - DatasetFieldsAverageMorphed.StructureName2, - DatasetFieldsAverageMorphed.PC_bin, - ] - ) diff --git a/cvapipe_analysis/tools/__init__.py b/cvapipe_analysis/tools/__init__.py index e69de29..40a96af 100644 --- a/cvapipe_analysis/tools/__init__.py +++ b/cvapipe_analysis/tools/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/cvapipe_analysis/tools/bincorrlib.pyx b/cvapipe_analysis/tools/bincorrlib.pyx deleted file mode 100644 index 4669723..0000000 --- a/cvapipe_analysis/tools/bincorrlib.pyx +++ /dev/null @@ -1,28 +0,0 @@ -#cython: language_level=3 - -cimport cython -cimport numpy as np -np.import_array() - -# cython e bool parecem não trabalhar bem juntos -DTYPE = int -ctypedef np.uint8_t DTYPE_t - -@cython.boundscheck(False) # turn off bounds-checking for entire function -@cython.wraparound(False) # turn off negative index wrapping for entire function -def calculate(np.ndarray[DTYPE_t, ndim=1] x, np.ndarray[DTYPE_t, ndim=1] y, int n): - cdef double tp, tn, fp, fn, xs, ys, xy - cdef int xi, yi, i - xs = 0 - ys = 0 - xy = 0 - for i in range(n): - xs += x[i] - ys += y[i] - xy += x[i]*y[i] - - tn = xy - tp = n - xs - ys + xy - fp = xs - xy - fn = n - (tp + tn + fp) - return (tp*tn-fp*fn)/((tp+fp)*(tp+fn)*(tn+fp)*(tn+fn))**0.5 \ No newline at end of file diff --git a/cvapipe_analysis/tools/cluster.py b/cvapipe_analysis/tools/cluster.py index 846531f..eafed58 100644 --- a/cvapipe_analysis/tools/cluster.py +++ b/cvapipe_analysis/tools/cluster.py @@ -1,11 +1,13 @@ import os import shutil +import concurrent import subprocess import numpy as np import pandas as pd from tqdm import tqdm from pathlib import Path -import cvapipe_analysis + +import cvapipe_analysis as cvapipe class Distributor: @@ -33,13 +35,20 @@ def __init__(self, step, control): self.abs_path_to_script_as_str = str(self.abs_path_to_distribute / "jobs.sh") self.abs_path_jobs_file_as_str = str(self.abs_path_to_distribute / "jobs.txt") self.abs_path_to_cvapipe = Path( - os.path.abspath(cvapipe_analysis.__file__)).parents[1] + os.path.abspath(cvapipe.__file__)).parents[1] def set_data(self, df): self.df = df + self.validate_data() self.nrows = len(df) self.chunk_size = round(0.5 + self.nrows / self.nworkers) + def validate_data(self): + if self.df.index.is_unique: + return + raise ValueError("Dataframe indexes are not unique.") + return + def set_chunk_size(self, n): self.chunk_size = n @@ -78,24 +87,23 @@ def append_job(self, job): self.jobs.append(job) def write_commands_file(self): - crtl = self.control - python__env_path_as_str = crtl.get_distributed_python_env_as_str() + python__env_path_as_str = self.control.get_distributed_python_env_as_str() with open(self.abs_path_jobs_file_as_str, "w") as fs: for job in self.jobs: abs_path_to_dataframe = str( self.abs_path_to_distribute / f"dataframes/{job}.csv") print( - f"{python__env_path_as_str} {self.get_abs_path_to_python_file_as_str()} --csv {abs_path_to_dataframe}", file=fs) + f"{python__env_path_as_str} {self.get_abs_path_to_python_file_as_str()} --csv {abs_path_to_dataframe} --staging {self.control.get_staging()}", file=fs) def write_script_file(self): - crtl = self.control abs_path_output_folder = self.abs_path_to_distribute / "log" with open(self.abs_path_to_script_as_str, "w") as fs: print("#!/bin/bash", file=fs) print("#SBATCH --partition aics_cpu_general", file=fs) - print(f"#SBATCH --mem-per-cpu {crtl.get_distributed_memory()}", file=fs) - print(f"#SBATCH --cpus-per-task {crtl.get_distributed_cores()}", file=fs) + print(f"#SBATCH --mem-per-cpu {self.control.get_distributed_memory()}", file=fs) + print(f"#SBATCH --cpus-per-task {self.control.get_distributed_cores()}", file=fs) print(f"#SBATCH --output {abs_path_output_folder}/%A_%a.out", file=fs) + print("#SBATCH --exclude=n81,n84,n88,n185,n178,n85", file=fs) print(f"#SBATCH --error {abs_path_output_folder}/%A_%a.err", file=fs) print(f"#SBATCH --array=1-{len(self.jobs)}", file=fs) print("#SBATCH --job-name=cvapipe", file=fs) @@ -147,6 +155,15 @@ def distribute_by_blocks(self): self.execute() return + def jobs_warning(self): + print("Multiple jobs have been launched. Please come back when the calculation is complete.") + + @staticmethod + def execute_in_parallel(func, it, njobs): + with concurrent.futures.ProcessPoolExecutor(njobs) as executor: + result = list(tqdm(executor.map(func, it), total=len(it))) + return result + class FeaturesDistributor(Distributor): def __init__(self, step, control): super().__init__(step, control) diff --git a/cvapipe_analysis/tools/controller.py b/cvapipe_analysis/tools/controller.py index 344ec09..2cf1872 100644 --- a/cvapipe_analysis/tools/controller.py +++ b/cvapipe_analysis/tools/controller.py @@ -1,11 +1,169 @@ +import sys import yaml import numpy as np import multiprocessing from pathlib import Path from aicsimageio import AICSImage +class GenericController: + """ + Generic controller that does not require a configuration + file to generate a shape space of a given dataset. + """ + + def __init__(self): + # Default parameters + self.config = {"log": {}} + self._removal_pct = 1.0 + self._Lmax = 16 + self._swapxy_on_zproj = False + self._aliases_for_pca = ["NUC"] + self._aliases_for_she = ["NUC"] + self._alignment_reference_alias = "NUC" + self._number_of_shape_modes = 8 + self._map_points = [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0] + self._shape_modes_plot_limits = [-150, 150, -80, 80] + self._shape_mode_plot_frames = True + self._colors = {"NUC": "black"} + + # DIRECTORIES + def set_output_folder(self, path): + self.abs_path_local_staging = Path(path) + + def get_abs_path_to_local_staging_folder(self): + return self.abs_path_local_staging + + def get_staging(self): # shortcut + return self.get_abs_path_to_local_staging_folder() + + def create_step_subdirs(self, step_dir, subdirs): + for subdir in subdirs: + path = step_dir / subdir + path.mkdir(parents=True, exist_ok=True) + + # SHE CALCULATION + def set_lmax(self, lmax): + self._Lmax = lmax + + def get_lmax(self): + return self._Lmax + + # ALIASES + def set_aliases_for_pca(self, aliases): + self._aliases_for_pca = aliases + + def get_aliases_for_pca(self): + return self._aliases_for_pca + + def get_features_for_pca(self, df): + prefixes = [f"{alias}_shcoeffs_L" for alias in self.get_aliases_for_pca()] + return [f for f in df.columns if any(w in f for w in prefixes)] + + def set_number_of_shape_modes(self, n): + self._number_of_shape_modes = n + + def get_number_of_shape_modes(self): + return self._number_of_shape_modes + + def get_shape_modes_prefix(self): + return "_".join(self.get_aliases_for_pca()) + + def get_shape_modes(self): + p = self.get_shape_modes_prefix() + return [f"{p}_PC{s}" for s in range(1, 1 + self.get_number_of_shape_modes())] + + def get_alias_for_sorting_pca_axes(self): + return "NUC" + + def iter_shape_modes(self): + for s in self.get_shape_modes(): + yield s + + def alignment_reference_alias(self, alias): + self._alignment_reference_alias = alias + + def get_alignment_reference_alias(self): + return self._alignment_reference_alias + + def set_aliases_with_shcoeffs_available(self, aliases): + self._aliases_for_she = aliases + + def get_aliases_with_shcoeffs_available(self): + return self._aliases_for_she + + def get_alignment_moving_aliases(self): + ref = self.get_alignment_reference_alias() + aliases = self.get_aliases_with_shcoeffs_available() + return [a for a in aliases if a != ref] + + # REMOVAL PCT + def set_removal_pct(self, pct): + self._removal_pct = pct -class Controller: + def get_removal_pct(self): + return self._removal_pct + + # MAP POINTS + def set_map_points(self, points): + self._map_points = points + + def get_map_points(self): + return self._map_points + + def get_number_of_map_points(self): + return len(self.get_map_points()) + + def get_map_point_indexes(self): + return np.arange(1, 1 + self.get_number_of_map_points()) + + def get_number_of_map_points(self): + return len(self.get_map_points()) + + def get_center_map_point_index(self): + return int(0.5 * (self.get_number_of_map_points() + 1)) + + def get_extreme_opposite_map_point_indexes(self, off=0): + mpIds = self.get_map_point_indexes() + return [mpIds[0 + off], mpIds[-1 - off]] + + # OTHER + def swapxy_on_zproj(self, val): + self._swapxy_on_zproj = val + + def swapxy_on_zproj(self): + return self._swapxy_on_zproj + + def set_plot_limits(self, limits): + self._shape_modes_plot_limits = limits + + def get_plot_limits(self): + return self._shape_modes_plot_limits + + def set_plot_frame(self, val): + self._shape_mode_plot_frames = val + + def get_plot_frame(self): + return self._shape_mode_plot_frames + + def set_color_for_alias(self, alias, color): + self._colors.update({alias: color}) + + def get_color_from_alias(self, alias): + return self._colors[alias] + + # STATICS + + @staticmethod + def display_array_size_in_mb(arr, print_func): + mem = int(sys.getsizeof(arr)) / float(1 << 20) + print_func(f"Array shape: {arr.shape} ({arr.dtype}, {mem:.1f}Mb)") + + @staticmethod + def get_ncores(): + return multiprocessing.cpu_count() + + +class Controller(GenericController): """ Functionalities for communicating with the config file. @@ -131,7 +289,7 @@ def should_calculate_intensity_features(self, alias): def get_mask_alias(self, alias): return [v for (k, v) in self.features_section['intensity'].items() if k==alias][0] - def get_lmax(self): + def get_Lmax(self): return self.features_section['SHE']['lmax'] def get_sigma(self, alias): @@ -140,13 +298,6 @@ def get_sigma(self, alias): def get_aliases_for_pca(self): return self.space_section['aliases'] - def get_features_for_pca(self, df): - prefixes = [f"{alias}_shcoeffs_L" for alias in self.get_aliases_for_pca()] - return [f for f in df.columns if any(w in f for w in prefixes)] - - def get_shape_modes_prefix(self): - return "_".join(self.get_aliases_for_pca()) - def get_alias_for_sorting_pca_axes(self): return self.space_section['sorter'] @@ -160,10 +311,6 @@ def get_removal_pct(self): def get_number_of_shape_modes(self): return self.space_section['number_of_shape_modes'] - def get_shape_modes(self): - p = self.get_shape_modes_prefix() - return [f"{p}_PC{s}" for s in range(1, 1 + self.get_number_of_shape_modes())] - def get_map_points(self): return self.space_section['map_points'] @@ -197,10 +344,6 @@ def iter_map_points(self): for m in self.get_map_points(): yield m - def iter_shape_modes(self): - for s in self.get_shape_modes(): - yield s - def get_inner_most_alias_to_parameterize(self): return self.param_section['inner'] @@ -224,6 +367,12 @@ def get_variables_values_for_aggregation(self, include_genes=True): variables['structure'] = [k for k in structs.keys()] return variables + def get_parameterized_representation_size(self): + phi_resolution = 64 # set in aicscytoparam + theta_resolution = 128 # set in aicscytoparam + nsurfaces = 1 + 2 * self.get_number_of_interpolating_points() + return nsurfaces * (phi_resolution * theta_resolution + 2) + def duplicate_variable(self, variables, v): vals = variables.pop(v) variables[f"{v}1"] = vals @@ -265,10 +414,6 @@ def get_optimal_avgseg_contrast(self, gene): def get_optimal_raw_contrast(self, gene): return eval(self.config["structures"][gene][2])["raw"] - @staticmethod - def get_ncores(): - return multiprocessing.cpu_count() - def get_distributed_python_env_as_str(self): path = Path(self.distribute_section['python_env']) / "bin/python" return str(path) diff --git a/cvapipe_analysis/tools/general.py b/cvapipe_analysis/tools/general.py index 3fbe43d..eec5e9b 100644 --- a/cvapipe_analysis/tools/general.py +++ b/cvapipe_analysis/tools/general.py @@ -4,40 +4,49 @@ from pathlib import Path from datetime import datetime from contextlib import contextmanager -from cvapipe_analysis.tools import controller +import cvapipe_analysis as cvapipe +from . import controller -def load_config_file(path: Path="./", fname="config.yaml"): - with open(Path(path)/fname, "r") as f: +def get_path_to_default_config(): + path = Path(cvapipe.__path__[0])/"resources" + return path + +def load_config_file(staging, fname="config.yaml"): + with open(Path(staging)/fname, "r") as f: config = yaml.load(f, Loader=yaml.FullLoader) + config["project"]["local_staging"] = str(staging) return config - -def save_config_file(path_to_folder): +def save_config_file(path_to_folder, filename="parameters.yaml"): + print("WARNING: This function is deprecated. Please use save_config instead.") + return path_to_folder = Path(path_to_folder) - shutil.copyfile("./config.yaml", path_to_folder/"parameters.yaml") + shutil.copyfile("./config.yaml", path_to_folder/filename) return - -def create_workflow_file_from_config(): - config = load_config_file() - local_staging = config['project']['local_staging'] - with open('workflow_config.json', 'w') as fj: - json.dump({'project_local_staging_dir': local_staging}, fj) - +def save_config(config, path, filename="config.yaml"): + with open(path/filename, "w") as f: + yaml.dump(config, f, sort_keys=False) def get_date_time(): return datetime.now().strftime("%d/%m/%Y %H:%M:%S") +def create_workflow_file_from_config(staging): + with open("workflow_config.json", "w") as fj: + json.dump({"project_local_staging_dir": staging}, fj) + +def check_installation(): + print(":: cvapipe_analysis seems to be properly installed! ::") @contextmanager -def configuration(path_to_folder=None): - config = load_config_file() +def configuration(step_dir): + staging = step_dir.parent + config = load_config_file(staging) control = controller.Controller(config) try: control.log({"start": get_date_time()}) yield control finally: - if path_to_folder is not None: - control.log({"end": get_date_time()}) - save_config_file(path_to_folder) + control.log({"end": get_date_time()}) + save_config(config, step_dir, filename="parameters.yaml") diff --git a/cvapipe_analysis/tools/io.py b/cvapipe_analysis/tools/io.py index 4bbe840..dacfd97 100644 --- a/cvapipe_analysis/tools/io.py +++ b/cvapipe_analysis/tools/io.py @@ -38,13 +38,15 @@ def __init__(self, control, subfolder=None): def get_single_cell_images(self, row, return_stack=False): imgs = [] channel_names = [] - imtypes = ["crop_raw", "crop_seg"] + imtypes = ["crop_path"]#["crop_seg","crop_raw","crop_path"] for imtype in imtypes: if imtype in row: path = Path(row[imtype]) if not path.is_file(): - path = self.control.get_staging() / f"loaddata/{row[imtype]}" - reader = AICSImage(path) + raise FileNotFoundError(path) + try: + reader = AICSImage(path) + except: ValueError(f"File {path} seems corrupted.") channel_names += reader.channel_names img = reader.get_image_data('CZYX', S=0, T=0) imgs.append(img) @@ -52,7 +54,8 @@ def get_single_cell_images(self, row, return_stack=False): name_dict = eval(row.name_dict) channel_names = [] for imtype in imtypes: - channel_names += name_dict[imtype] + if imtype in row: + channel_names += name_dict[imtype] except Exception as ex: if not channel_names: raise ValueError(f"Channel names not found, {ex}") @@ -94,9 +97,7 @@ def load_step_manifest(self, step, clean=False, **kwargs): df = self.write_compute_features_manifest_from_distributed_results() else: df = pd.read_csv( - self.get_abs_path_to_step_manifest(step), - index_col="CellId", low_memory=False, **kwargs - ) + self.get_abs_path_to_step_manifest(step), index_col="CellId", dtype={"CellId": str}, low_memory=False, **kwargs) if clean: feats = ['mem_', 'dna_', 'str_'] #TODO: fix the aliases here @@ -124,12 +125,16 @@ def read_parameterized_intensity(self, index, return_intensity_names=False): code, intensity_names = None, [] path = f"parameterization/representations/{index}.tif" path = self.control.get_staging() / path - if path.is_file(): + if not path.is_file(): + raise FileNotFoundError(path) + try: code = AICSImage(path) - intensity_names = code.channel_names - code = code.data.squeeze() - if code.ndim == 2: - code = code.reshape(1, *code.shape) + except: + raise ValueError(f"File {path} seems corrupted. Consider re-running parameterization.") + intensity_names = code.channel_names + code = code.data.squeeze() + if code.ndim == 2: + code = code.reshape(1, *code.shape) if return_intensity_names: return code, intensity_names return code @@ -138,7 +143,8 @@ def read_parameterized_intensity(self, index, return_intensity_names=False): def normalize_representations(reps): # Expected shape is SCMN if reps.ndim != 4: - raise ValueError(f"Input shape {reps.shape} does not match expected SCMN format.") + # CAMN = Cell, Alias, Theta and Phi resolutions + raise ValueError(f"Input shape {reps.shape} does not match expected CAMN format.") count = np.sum(reps, axis=(-2,-1), keepdims=True) reps_norm = np.divide(reps, count, out=np.zeros_like(reps), where=count>0) return reps_norm @@ -183,9 +189,10 @@ def load_results_in_single_dataframe(self, path=None): ''' Not sure this function is producing a column named index when the concordance results are loaded. Further investigation is needed here''' + df_full = self.load_step_manifest("loaddata") if path is None: path = self.control.get_staging() / self.subfolder - files = [{"csv": path/f} for f in os.listdir(path)] + files = [{"csv": f"{path/f}.csv"} for f in df_full.index] with concurrent.futures.ProcessPoolExecutor(self.control.get_ncores()) as executor: df = pd.concat( tqdm(executor.map(self.load_data_from_csv, files), total=len(files)), @@ -201,7 +208,7 @@ def read_corelation_matrix(self, row, return_cellids=False): print(f"Correlation matrix {fname} not found.") return None np.fill_diagonal(corr, np.nan) - corr_idx = pd.read_csv(f"{self.control.get_staging()}/correlation/values/{fname}.csv", index_col=0) + corr_idx = pd.read_csv(f"{self.control.get_staging()}/correlation/values/{fname}.csv", index_col=0, dtype={"CellId": str}) df_corr = pd.DataFrame(corr) # Include structure name information into the correlation matrix df = self.load_step_manifest("loaddata") @@ -229,9 +236,13 @@ def build_correlation_matrix_of_avg_reps_from_corr_values(self, row, genes=None) for gid1, gene1 in enumerate(genes): for gid2, gene2 in enumerate(genes): if gid2 > gid1: + person = np.nan fname = self.get_correlation_matrix_file_prefix(row, genes=(gene1,gene2)) - df = pd.read_csv(f"{self.control.get_staging()}/concordance/values/{fname}.csv") - matrix[gid1, gid2] = matrix[gid2, gid1] = df.Pearson.values[0] + fname = f"{self.control.get_staging()}/concordance/values/{fname}.csv" + if os.path.exists(fname): + df = pd.read_csv(fname) + person = df.Pearson.values[0] + matrix[gid1, gid2] = matrix[gid2, gid1] = person return matrix def get_correlation_of_mean_reps(self, row, return_ncells=False): @@ -266,7 +277,7 @@ def load_data_from_csv(parameters, use_fms=False): if use_fms: fms = FileManagementSystem() fmsid = parameters['fmsid'] - record = fms.find_one_by_id(fmsid) + record = fms.get_file_by_id(fmsid) if record is None: raise ValueError(f"Record {fmsid} not found on FMS.") path = record.path @@ -274,9 +285,7 @@ def load_data_from_csv(parameters, use_fms=False): path = Path(parameters['csv']) if not path.is_file(): raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), path) - df = pd.read_csv(path) - # Backwards compatibility for new DVC data - df = df.rename(columns={"crop_seg_path": "crop_seg", "crop_raw_path": "crop_raw"}) + df = pd.read_csv(path, dtype={"CellId": str}) return df @staticmethod @@ -306,7 +315,7 @@ def status(idx, output, computed): def load_csv_file_as_dataframe(fpath): df = None try: - df = pd.read_csv(fpath) + df = pd.read_csv(fpath, dtype={"CellId": str}) except: pass return df @@ -346,6 +355,7 @@ class DataProducer(LocalStagingIO): """ def __init__(self, control): + self._verbose = False super().__init__(control) def workflow(self): @@ -357,6 +367,16 @@ def get_output_file_name(self): def save(self): return None + def set_verbose_mode_on(self): + self._verbose = True + + def verbose_mode(self, verbose=True): + self._verbose = verbose + + def print(self, text): + if self._verbose: + print(text) + def set_row(self, row): self.row = row if "CellIds" in row: diff --git a/cvapipe_analysis/tools/plotting.py b/cvapipe_analysis/tools/plotting.py index 765511c..33de45f 100644 --- a/cvapipe_analysis/tools/plotting.py +++ b/cvapipe_analysis/tools/plotting.py @@ -15,7 +15,9 @@ from scipy import cluster as spcluster from aicsimageio import AICSImage, writers from vtk.util import numpy_support as vtknp -from cvapipe_analysis.tools import io, shapespace +from matplotlib.ticker import FormatStrFormatter + +from . import io, shapespace plt.rcParams['ps.fonttype'] = 42 plt.rcParams['pdf.fonttype'] = 42 @@ -121,9 +123,11 @@ def get_aggregated_matrix_from_df(genes, df_corr): for gid1, gene1 in enumerate(genes): for gid2, gene2 in enumerate(genes): if gid2 >= gid1: - values = df_corr.loc[(gene1, gene2)].values - avg = np.nanmean(values) - std = np.nanstd(values) + avg = np.nan + if (gene1 in df_corr.columns) & (gene2 in df_corr.columns): + values = df_corr.loc[(gene1, gene2)].values + avg = np.nanmean(values) + std = np.nanstd(values) matrix[gid1, gid2] = matrix[gid2, gid1] = avg return matrix @@ -191,7 +195,8 @@ def get_agg_correlation_matrix(self, create_mirrored_matrix=False, relative_to_c df_corr = self.device.read_corelation_matrix(row) if update_ncells: for struct, gene in zip(self.control.get_structure_names(), self.control.get_gene_names()): - self.ncells[struct] = len(df_corr.loc[gene]) + if gene in df_corr.columns: + self.ncells[struct] = len(df_corr.loc[gene]) if df_corr is None: return genes = self.control.get_gene_names() @@ -395,33 +400,34 @@ def make_boxplot(self): fig, ax = plt.subplots(1, 1, figsize=(7, 8), dpi=self.dpi) for sid, gene in enumerate(reversed(self.control.get_gene_names())): - values = df_corr.loc[gene, gene].values - ncells = values.shape[0] - values = values[np.triu_indices(ncells, k=1)] - - np.random.seed(42) - x = np.random.choice(values, np.min([ncells, 1024]), replace=False) - y = np.random.normal(size=len(x), loc=sid, scale=0.1) - ax.scatter(x, y, s=1, c="k", alpha=0.1) - box = ax.boxplot( - values, - positions=[sid], - showmeans=True, - widths=0.75, - sym="", - vert=False, - patch_artist=True, - meanprops={ - "marker": "s", - "markerfacecolor": "black", - "markeredgecolor": "white", - "markersize": 5, - }, - ) - label = f"{self.control.get_structure_name(gene)} (N={ncells:04d})" - labels.append(label) - box["boxes"][0].set(facecolor=self.control.get_gene_color(gene)) - box["medians"][0].set(color="black") + if gene in df_corr.columns: + values = df_corr.loc[gene, gene].values + ncells = values.shape[0] + values = values[np.triu_indices(ncells, k=1)] + + np.random.seed(42) + x = np.random.choice(values, np.min([ncells-1, 1024]), replace=False) + y = np.random.normal(size=len(x), loc=sid, scale=0.1) + ax.scatter(x, y, s=1, c="k", alpha=0.1) + box = ax.boxplot( + values, + positions=[sid], + showmeans=True, + widths=0.75, + sym="", + vert=False, + patch_artist=True, + meanprops={ + "marker": "s", + "markerfacecolor": "black", + "markeredgecolor": "white", + "markersize": 5, + }, + ) + label = f"{self.control.get_structure_name(gene)} (N={ncells:04d})" + labels.append(label) + box["boxes"][0].set(facecolor=self.control.get_gene_color(gene)) + box["medians"][0].set(color="black") ax.set_yticklabels(labels) ax.set_xlim(-0.2, 1.0) ax.set_xlabel("Pearson correlation coefficient", fontsize=14) @@ -495,7 +501,6 @@ def plot_explained_variance(self, space): def save_feature_importance(self, space): path = f"{self.subfolder}/feature_importance.txt" abs_path_txt_file = self.control.get_staging() / path - print(abs_path_txt_file) with open(abs_path_txt_file, "w") as flog: for col, sm in enumerate(self.control.iter_shape_modes()): exp_var = 100 * space.pca.explained_variance_ratio_[col] @@ -551,7 +556,7 @@ def plot_pairwise_correlations(self, space, off=0): ymax = y[valids].max() yrange.append([ymin, ymax]) ax.plot(x[valids], y[valids], ".", - markersize=2, color="black", alpha=0.8) + markersize=2, color="black", alpha=0.05) ax.plot([xmin, xmax], [xmin, xmax], "--") if f2id: plt.setp(ax.get_yticklabels(), visible=False) @@ -743,7 +748,8 @@ def comparative_hists(df1, df2, title, bin_edges, display_both=True, ymax=1): nc = len(df1.columns) args = {"bins": bin_edges, "density": True} fig, axs = plt.subplots(1, nc, figsize=(1.5*nc, 1.5), sharex=False, gridspec_kw={"wspace": 0.2}) - axs = [axs] if len(axs)==1 else axs + if not isinstance(axs, list): + axs = [axs] for sm, ax in zip(df1.columns, axs): ax.set_frame_on(False) if display_both: @@ -875,3 +881,40 @@ def plot_distance_vs_ncells(self): plt.suptitle(ds, fontsize=14) plt.tight_layout() self.figs.append((fig, f"nndist_ncells_{ds}")) + +class ValidationPlotMaker(PlotMaker): + """ + Class for creating validation plots. + + WARNING: This class should not depend on where + the local_staging folder is. + """ + + def __init__(self, control, subfolder: Optional[str] = None): + super().__init__(control) + self.subfolder = "validation/rec_error" if subfolder is None else subfolder + + def workflow(self): + self.make_reconstructin_error_plots() + + def make_reconstructin_error_plots(self): + for alias, df_alias in self.df.groupby("alias"): + fig, ax = plt.subplots(1,1,figsize=(3.7,3)) + for _, df_cell in df_alias.groupby('CellId'): + x = (df_cell.lrec+1)**2 + ax.plot(x, df_cell.error, '-', color='gray', linewidth=0.2) + df_agg = df_alias.groupby('lrec').agg(['mean','std']) + x = (df_agg.index+1)**2 + ax.plot(x, df_agg[('error','mean')],'-', color='k', linewidth=2) + ax.set_yscale('log') + ax.axvline(x=289) + ax.set_xlim(1,33**2) + ax.set_ylim(0.1,10.0) + ax.yaxis.set_major_formatter(FormatStrFormatter('%.1f')) + err_avg = df_agg.at[16,('error','mean')] + err_std = df_agg.at[16,('error','std')] + ax.set_title(f"{alias}, @L=16: {err_avg:.2f} +/- {err_std:.2f} $\mu m$") + ax.set_xlabel('L (SHE order)', fontsize=14) + ax.set_ylabel('Mean distance to closest point($\mu m$)') + plt.tight_layout() + self.figs.append((fig, f"rec_error_{alias}")) diff --git a/cvapipe_analysis/tools/shapespace.py b/cvapipe_analysis/tools/shapespace.py index 2b60b5c..f98c0bc 100644 --- a/cvapipe_analysis/tools/shapespace.py +++ b/cvapipe_analysis/tools/shapespace.py @@ -25,11 +25,19 @@ class ShapeSpaceBasic(): active_shape_mode = None def __init__(self, control): + self._verbose = False self.control = control def set_active_shape_mode(self, sm): self.active_shapeMode = sm + def verbose_mode(self, verbose): + self._verbose = verbose + + def print(self, text): + if self._verbose: + print(text) + @staticmethod def get_aggregated_df(variables): df = ShapeSpaceBasic.expand(variables) @@ -112,6 +120,7 @@ def workflow(self): self.calculate_feature_importance() pct = self.control.get_removal_pct() if self.remove_extreme_points_on else 0.0 self.shape_modes = self.remove_extreme_points(self.axes, pct) + self.print("Shape space computed.") def set_remove_extreme_points(self, value): self.remove_extreme_points_on = value @@ -119,13 +128,17 @@ def set_remove_extreme_points(self, value): def calculate_pca(self): self.df_pca = self.df[self.features] matrix_of_features = self.df_pca.values.copy() - pca = PCA(self.control.get_number_of_shape_modes()) + pca = PCA(self.control.get_number_of_shape_modes(), svd_solver="full") pca = pca.fit(matrix_of_features) axes = pca.transform(matrix_of_features) self.axes = pd.DataFrame(axes, columns=self.control.get_shape_modes()) self.axes.index = self.df_pca.index self.pca = pca - self.sort_pca_axes() + try: + self.sort_pca_axes() + except Exception as e: + print(f"Failed sorting PCA axes: {e}. Skipping this step.") + pass return def transform(self, df): @@ -295,7 +308,7 @@ def get_cells_inside_ndsphere_of_radius(self, radius=2.10, return_dist=False, di # number of center per structure averaged over 8 center bins. # Refer to notebook Optimization8DimSphere for more # details on the optimization process. - df_agg = pd.DataFrame([]) + df_agg = [] dist = self.shape_modes.copy() if dims_to_use is not None: dist = dist[dims_to_use] @@ -315,7 +328,8 @@ def get_cells_inside_ndsphere_of_radius(self, radius=2.10, return_dist=False, di "structure": gene, "CellIds": CellIds } - df_agg = df_agg.append(row, ignore_index=True) + df_agg.append(row) + df_agg = pd.DataFrame(df_agg) df_agg.mpId = df_agg.mpId.astype(np.int64) if return_dist: return df_agg, df_dist @@ -405,7 +419,7 @@ def merge_transformed_datasets(self): self.result["dataset"] = "base" for ds, dspath in self.datasets.items(): df = pd.read_csv(f"{dspath}/preprocessing/manifest.csv", index_col="CellId") - print(f"\t{ds} loaded. {df.shape}") + self.print(f"\t{ds} loaded. {df.shape}") axes = self.space.transform(df) axes["dataset"] = ds axes["structure_name"] = df["structure_name"] @@ -459,8 +473,9 @@ def reconstruct_matched_datasets_mean_cell(self): from the baseline dataset. ''' # Start by reading the config file from perturbed dataset - path_step = Path(self.datasets[ds]) / "shapemode" - config_pt = general.load_config_file(path_step, fname="parameters.yaml") + # import pdb; pdb.set_trace() + # path_step = Path(self.datasets[ds]) / "shapemode" + config_pt = general.load_config_file(self.datasets[ds]) control_pt = controller.Controller(config_pt) # Now we merge the two datasets together device_pt = io.LocalStagingIO(control_pt) @@ -513,6 +528,6 @@ def create_nn_mapping(self): df_map.loc[df_Y.index, "Dist"] = dist.min(axis=0) df_map.loc[df_Y.index, "SelfDist"] = self_distance df_map.loc[df_Y.index, "NNCellId"] = df_X.index[dist.argmin(axis=0)] - df_map.NNCellId = df_map.fillna(-1).NNCellId.astype(np.int64) + df_map.NNCellId = df_map.fillna(-1).NNCellId#.astype(np.int64) CellId does not need to be int self.result = df_map self.result.reset_index().set_index(["dataset", "CellId"]) diff --git a/cvapipe_analysis/tools/viz.py b/cvapipe_analysis/tools/viz.py index dc1b512..235a2db 100644 --- a/cvapipe_analysis/tools/viz.py +++ b/cvapipe_analysis/tools/viz.py @@ -6,6 +6,7 @@ from aicsshparam import shtools import matplotlib.pyplot as plt from matplotlib import animation +from scipy import spatial as spspatial from vtk.util import numpy_support as vtknp class MeshToolKit(): @@ -19,18 +20,18 @@ def get_mesh_from_series(row, alias, lmax): # Cosine SHE coefficients coeffs[0, l, m] = row[ [f for f in row.keys() if f"{alias}_shcoeffs_L{l}M{m}C" in f] - ] + ].iloc[0] # Sine SHE coefficients coeffs[1, l, m] = row[ [f for f in row.keys() if f"{alias}_shcoeffs_L{l}M{m}S" in f] - ] + ].iloc[0] # If a given (l,m) pair is not found, it is assumed to be zero except: pass mesh, _ = shtools.get_reconstruction_from_coeffs(coeffs) return mesh @staticmethod - def find_plane_mesh_intersection(mesh, proj, use_vtk_for_intersection=True): + def find_plane_mesh_intersection(mesh, proj, use_vtk_for_intersection=True, verbose=False): # Find axis orthogonal to the projection of interest axis = [a for a in [0, 1, 2] if a not in proj][0] @@ -38,9 +39,15 @@ def find_plane_mesh_intersection(mesh, proj, use_vtk_for_intersection=True): # Get all mesh points points = vtknp.vtk_to_numpy(mesh.GetPoints().GetData()) + if verbose: + print("\t\t\tChecking if points exist...") + if not np.abs(points[:, axis]).sum(): raise Exception("Only zeros found in the plane axis.") + if verbose: + print("\t\t\tOK") + if use_vtk_for_intersection: mid = np.mean(points[:, axis]) @@ -48,13 +55,13 @@ def find_plane_mesh_intersection(mesh, proj, use_vtk_for_intersection=True): Without this the code hangs when the mesh has any edge aligned with the projection plane. Also add a little of noisy to the coordinates to help with the same problem.''' - mid += 0.75 + # mid += 0.75 offset = 0.1 * np.ptp(points, axis=0).max() # Create a vtkPlaneSource plane = vtk.vtkPlaneSource() - plane.SetXResolution(4) - plane.SetYResolution(4) + plane.SetXResolution(32) + plane.SetYResolution(32) if axis == 0: plane.SetOrigin( mid, points[:, 1].min() - offset, points[:, 2].min() - offset @@ -88,6 +95,20 @@ def find_plane_mesh_intersection(mesh, proj, use_vtk_for_intersection=True): plane.Update() plane = plane.GetOutput() + print("\t\t\tJittering plane coordinates...") + + coords = vtknp.vtk_to_numpy(plane.GetPoints().GetData()) + coords[:, axis] = 0.5 * (np.random.rand(coords.shape[0])-0.5)*2 + plane.GetPoints().SetData(vtknp.numpy_to_vtk(coords)) + + print("\t\t\tSaving shapes...") + + from aicsshparam import shtools + shtools.save_polydata(plane, "/allen/aics/assay-dev/MicroscopyOtherData/Viana/projects/trash/0debug_plane.vtk") + shtools.save_polydata(mesh, "/allen/aics/assay-dev/MicroscopyOtherData/Viana/projects/trash/0debug_mesh.vtk") + + print("\t\t\tChecking intersection...") + # Trangulate the plane triangulate = vtk.vtkTriangleFilter() triangulate.SetInputData(plane) @@ -101,6 +122,8 @@ def find_plane_mesh_intersection(mesh, proj, use_vtk_for_intersection=True): intersection.Update() intersection = intersection.GetOutput() + print("\t\t\tDone...") + # Get coordinates of intersecting points points = vtknp.vtk_to_numpy(intersection.GetPoints().GetData()) coords = points[:, proj] @@ -167,17 +190,27 @@ def sort_2d_points(coords): return np.array(coords) @staticmethod - def get_2d_contours(named_meshes, swapxy_on_zproj=False): + def get_2d_contours(named_meshes, swapxy_on_zproj=False, use_vtk=True, verbose=False): contours = {} projs = [[0, 1], [0, 2], [1, 2]] + if verbose: + print(f"VTK for plane instersection: {use_vtk}") if swapxy_on_zproj: projs = [[0, 1], [1, 2], [0, 2]] for dim, proj in zip(["z", "y", "x"], projs): + if verbose: + print(f"Running proj: {proj}") contours[dim] = {} for alias, meshes in named_meshes.items(): contours[dim][alias] = [] - for mesh in meshes: - coords = MeshToolKit.find_plane_mesh_intersection(mesh, proj) + for mid, mesh in enumerate(meshes): + if verbose: + print(f"\t\tRunning alias: {alias} for mesh: {mid}") + try: + coords = MeshToolKit.find_plane_mesh_intersection( + mesh, proj, use_vtk_for_intersection=use_vtk, verbose=verbose) + except Exception as ex: + raise ValueError(f"Plane intersection failed: {ex}. Try setting use_vtk=False.") if swapxy_on_zproj and dim == 'z': coords = coords[:, ::-1] contours[dim][alias].append(coords) @@ -220,3 +253,12 @@ def animate(i): plt.close("all") return return anim + + @staticmethod + def get_meshes_distance(mesh1, mesh2): + coords1 = vtknp.vtk_to_numpy(mesh1.GetPoints().GetData()) + coords2 = vtknp.vtk_to_numpy(mesh2.GetPoints().GetData()) + dist = spspatial.distance.cdist(coords1, coords2) + d12 = dist.min(axis=0) + d21 = dist.min(axis=1) + return d12, d21 diff --git a/notebooks/FigureEdges/FigureEdges1-Decouple.ipynb b/notebooks/FigureEdges/FigureEdges1-Decouple.ipynb new file mode 100644 index 0000000..9c91535 --- /dev/null +++ b/notebooks/FigureEdges/FigureEdges1-Decouple.ipynb @@ -0,0 +1,488 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "62198de3", + "metadata": {}, + "outputs": [], + "source": [ + "# Histograms comparing different datasets (edges vs. non-edge cell sin the paper)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "80380f9a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wed Apr 26 14:38:03 PDT 2023\r\n" + ] + } + ], + "source": [ + "!date" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f2a8d25a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/matheus.viana/anaconda3/envs/lab-variance/bin/python\r\n" + ] + } + ], + "source": [ + "!which python" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c426601f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cvapipe-analysis 0.1.0 /allen/aics/assay-dev/MicroscopyOtherData/Viana/projects/cvapipe_analysis\r\n" + ] + } + ], + "source": [ + "!pip list | grep cvapipe" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "afbe00f8", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import importlib\n", + "import concurrent\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pathlib import Path\n", + "from tqdm.notebook import tqdm\n", + "from skimage import io as skio\n", + "import matplotlib.pyplot as plt\n", + "from aicscytoparam import cytoparam\n", + "from aicsshparam import shtools, shparam\n", + "from aicsimageio import AICSImage\n", + "from aicsimageio.writers import OmeTiffWriter\n", + "from cvapipe_analysis.tools import io, viz, general, controller, shapespace, plotting\n", + "\n", + "sys.path.insert(1, '../tools')\n", + "import common" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0a8857c4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(147, 1218) /allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca9\n" + ] + } + ], + "source": [ + "# Controller form cvapipe_analysis\n", + "staging = Path(\"/allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca9\")\n", + "control = controller.Controller(general.load_config_file(staging))\n", + "device = io.LocalStagingIO(control)\n", + "df = device.load_step_manifest(\"preprocessing\")\n", + "print(df.shape, control.get_staging())" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "60f993a5", + "metadata": {}, + "outputs": [], + "source": [ + "space = shapespace.ShapeSpace(control)\n", + "space.execute(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "27982e26", + "metadata": {}, + "outputs": [], + "source": [ + "datasets = {\n", + " \"pca62\": {\n", + " \"perturbed\": \"/allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca62\"\n", + " }}" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "426413fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(general)\n", + "importlib.reload(shapespace)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "39fcfac8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tpca62 loaded. (138, 1218)\n" + ] + } + ], + "source": [ + "smapper = shapespace.ShapeSpaceMapper(space, output_folder=\"./\")\n", + "smapper.use_full_base_dataset()\n", + "smapper.set_make_plots_off()\n", + "smapper.set_distance_threshold(1e10)\n", + "smapper.map(datasets)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "e045ce28", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(plotting)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "94e46be5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGoAAABvCAYAAAAE7FUkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAC4UlEQVR4nO3cz4tNcRzG8fczkRXKLFhQFqQUNgrlH2BBWVB2Q42tnZTS/AN+bORHSbFjgwVZkUTCBmWJLG1EMTX6WMyZujHmmmPunHmm51Wnzp3Oj0+953xnzuaqqoiFb6jrAeLfJJSJhDKRUCYSykRCmUgoEwllIqFMJJSJhDKRUCYSykRCmUgoEwllIqFMJJSJhDKRUCYSykRCmUgoEwllIqFMJJSJhDKRUCYSykRCmUgoEwllIqFMJJSJhDKRUCYSykRCmUgoEwllIqFMJJSJhDKRUCYSykRCmVjS9QBTxneMfl42UcNdz/EPPvDyyvr5vumCCbVsoobH9q091vUc/Zy+8+lSF/fN0mcioUwklImEMpFQJhLKREKZSCgTCWUioUwklImEMpFQJhLKREKZSCgTCWUioUwklImEMpFQJhLKREKZSCgTCWUioUwklImEMpFQJhLKREKZSCgTCWUioUwklImEMpFQJhLKREK5qKpZb8Bom/Pme1tMc7Z9okbn6Pdk0BbNnFn6TCSUibahLs/pFIOzaOZU88csFrgsfSYSykSrUJJWSror6ZGkp5J2zfVgbUkaknSxmeuhpA1dzzQdSUslXZf0WNJzSftmPKHlC9oYcLzZ3wS86vqlsWe2A8C1Zn8ncLvrmf4y5whwrtlfBXyc6fi234B5Fhhv9pcAP1peZxB2A/cBquqZpO0dz/M3N4Fbzb6AiZkO7rv0SToq6U3vBmysqu+S1gA3gJP/O/UcWgF86fn8U9KC+UrWKVX1raq+SlrOZLBT/U5o++huAd4Ce7peRn6b6wxwsOfzp65nmmHWdcAL4Ei/Y9v+M7GZyUf3cFXda3ONAXoC7AWQtBN43e0405O0GngAnKiqq32Pb8rO9ia3gW3A++ZHX6pq/6wvNACShoALwFYm1/6RqnrX7VR/knQeOAT0zranqr5Pe3ybUDH/8sJrIqFMJJSJhDKRUCYSykRCmfgFxgDZLSxdqH8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGoAAABvCAYAAAAE7FUkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAC1ElEQVR4nO3cz4tNcRzG8fczjSXKho1YkFLYWIzyD4wFZUHZDWVtJ2XjH/BjI1lIsWMzWZAVSSTZoCyH/AMTNRR9LOZM3Zi5d+a4d859pudVp86dvvfcT/fd+TZ3c1RVxPib6HqAWJ2EMpFQJhLKREKZSCgTCWUioUwklImEMpFQJhLKREKZSCgTCWUioUwklImEMpFQJhLKREKZSCgTCWUioUwklImEMpFQJhLKREKZSCgTCWUioUwklImEMpFQJhLKREKZSCgTCWUioUwklImEMpFQJhLKREKZSCgTk10PsETSHLCr6zlW4XNV7V7vD9W4PK9PUlWVup5jkK7mzNZnIqFMJJSJhDKRUCYSykRCmUgoEwllIqFMJJSJhDKRUCYSykRCmUgoEwllIqFMJJSJhDKRUCYSykRCmUgoEwllIqFMJJSJhDKRUCYSykRCmUgoEwllIqFMJJSJhDKRUCYSykRCmWgVStL5YQ8yimc3bKQ5295RQ/8CRmTDzJmtz0RCmWgb6vZQpxidDTPn2Dy0KvrL1mcioUy0/R21VdIjSc8lvZJ0ZNiDtSVpQtKtZq5nkvZ0PdNyJG2SdE/SC0lvJB3v+4aqWvMBXAEuNOf7gHdtrjOKAzgJ3G3Op4DZrmdaYc4Z4Hpzvg340m9920eVXgN+NueTwI+W1xmFo8ATgKp6Lelwx/Os5AHwsDkX8Kvf4oFbn6Rzkj70HsDeqlqQtAO4D1z636mHaAsw3/P6t6SxeXbukqr6XlXfJG1mMdjlQW9oe+seAD4C011vI3/NdRU41fP6a9cz9Zl1J/AWODtobdt/JvazeOueqarHba4xQi+BYwCSpoD33Y6zPEnbgafAxaq6M3B9U3atHzILHALmmj/NV9WJNV9oBCRNADeBgyzu/TNV9anbqf4l6QZwGuidbbqqFpZd3yZUrL/84DWRUCYSykRCmUgoEwllIqFM/AGNr64/jKkd5AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pmaker = plotting.ShapeSpaceMapperPlotMaker(control, \"./\")\n", + "pmaker.set_dataframe(smapper.result)\n", + "pmaker.plot_mapping_1d(display_both=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "91389f07", + "metadata": {}, + "outputs": [], + "source": [ + "for (fig, _), name in zip(pmaker.figs, [\"hists\", \"hists_matched\"]):\n", + " fig.savefig(f\"{name}.pdf\")" + ] + }, + { + "cell_type": "markdown", + "id": "168d4904", + "metadata": {}, + "source": [ + "### Reconstruct shapes of individual and matched datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "e6beb370", + "metadata": {}, + "outputs": [], + "source": [ + "# These variables should match between control and perturbed dataset\n", + "nisos = control.get_number_of_interpolating_points()\n", + "inner_alias = control.get_inner_most_alias_to_parameterize()\n", + "outer_alias = control.get_outer_most_alias_to_parameterize()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "593be240", + "metadata": {}, + "outputs": [], + "source": [ + "# path_step = Path(datasets[\"edges\"][\"perturbed\"]) / \"shapemode\"\n", + "config_pt = general.load_config_file(datasets[\"pca62\"][\"perturbed\"])\n", + "control_pt = controller.Controller(config_pt)\n", + "device_pt = io.LocalStagingIO(control_pt)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "f98aeb55", + "metadata": {}, + "outputs": [], + "source": [ + "meshes = {\"ct\": {}, \"pt\": {}, \"mt\": {}}\n", + "meshes[\"ct\"][\"inner\"] = device.read_mean_shape_mesh(inner_alias)\n", + "meshes[\"ct\"][\"outer\"] = device.read_mean_shape_mesh(outer_alias)\n", + "meshes[\"pt\"][\"inner\"] = device_pt.read_mean_shape_mesh(inner_alias)\n", + "meshes[\"pt\"][\"outer\"] = device_pt.read_mean_shape_mesh(outer_alias)\n", + "meshes[\"mt\"][\"inner\"] = device.read_vtk_polydata(f\"./avgshape/pca62_{inner_alias}_matched.vtk\")\n", + "meshes[\"mt\"][\"outer\"] = device.read_vtk_polydata(f\"./avgshape/pca62_{outer_alias}_matched.vtk\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "ebd0149b", + "metadata": {}, + "outputs": [], + "source": [ + "instances = []\n", + "for _, mesh in meshes.items():\n", + " domain, _ = cytoparam.voxelize_meshes([mesh[\"outer\"], mesh[\"inner\"]]) \n", + " domain = np.pad(domain, ((5,5),(5,5),(5,5)))\n", + " domain_nuc = (255*(domain>1)).astype(np.uint8)\n", + " domain_mem = (255*(domain>0)).astype(np.uint8)\n", + " instances.append(np.stack([domain_nuc, domain_mem, domain_mem], axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "a0a86990", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 50, 135, 363)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "instances[0].shape <<<<< not working here" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "07f926fa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mode = {\n", + " \"nuc\": \"center_nuc\",\n", + " \"mem\": \"center_nuc\",\n", + " \"gfp\": \"center_nuc\"\n", + "}\n", + "importlib.reload(common)\n", + "args = {\"gridspec_kw\": {\"hspace\": 0, \"wspace\": -0.1}, \"sharex\": True, \"sharey\": True}\n", + "for orient in [\"z\", \"y\", \"x\"]:\n", + " for alias in [\"nuc\", \"mem\"]:\n", + " fig, axs = plt.subplots(1,len(instances), figsize=(2*len(instances), 2), **args)\n", + " for ax, instance in zip(axs, instances):\n", + " ax.axis(\"off\")\n", + " proj = common.Projector(instance, box_size=400)\n", + " proj.set_projection_mode(ax=orient, mode=mode)\n", + " proj.project_on(alias=alias, ax=ax, scale_bar={\"pixel_size\":0.18, \"length\":15})\n", + " plt.savefig(f\"Figure1_shapes_{alias}_{orient}.png\", dpi=150)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "b66678d1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "complete 2023-04-26 21:56:43\n" + ] + } + ], + "source": [ + "common.now(\"complete\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3154642e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/FigureEdges/FigureEdges2-Decouple.ipynb b/notebooks/FigureEdges/FigureEdges2-Decouple.ipynb new file mode 100644 index 0000000..9a6c3a3 --- /dev/null +++ b/notebooks/FigureEdges/FigureEdges2-Decouple.ipynb @@ -0,0 +1,435 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "987615bd", + "metadata": {}, + "outputs": [], + "source": [ + "# Display the avg location of a particular structure in the mean shape of the matched dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "696163b2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Thu Apr 27 09:09:21 PDT 2023\r\n" + ] + } + ], + "source": [ + "!date" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f0382da7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/matheus.viana/anaconda3/envs/lab-variance/bin/python\r\n" + ] + } + ], + "source": [ + "!which python" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b0e6580e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cvapipe-analysis 0.1.0 /allen/aics/assay-dev/MicroscopyOtherData/Viana/projects/cvapipe_analysis\r\n" + ] + } + ], + "source": [ + "!pip list | grep cvapipe" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "26627787", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import importlib\n", + "import concurrent\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pathlib import Path\n", + "from tqdm.notebook import tqdm\n", + "from skimage import io as skio\n", + "import matplotlib.pyplot as plt\n", + "from aicscytoparam import cytoparam\n", + "from aicsshparam import shtools, shparam\n", + "from aicsimageio import AICSImage\n", + "from aicsimageio.writers import OmeTiffWriter\n", + "from cvapipe_analysis.tools import io, viz, general, controller, shapespace, plotting\n", + "\n", + "sys.path.insert(1, '../tools')\n", + "import common" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "81462cf1", + "metadata": {}, + "outputs": [], + "source": [ + "genes = [\"SARC\", \"FRET\", \"ADH\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7bf5721a", + "metadata": {}, + "outputs": [], + "source": [ + "datasets = {\n", + " \"pca62\": {\n", + " \"control\": \"/allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca9\",\n", + " \"perturbed\": \"/allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca62\"\n", + " }}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "39be681d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(common)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "983a17a6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/matheus.viana/anaconda3/envs/lab-variance/lib/python3.8/site-packages/ome_types/_convenience.py:105: FutureWarning: The default XML parser will be changing from 'xmlschema' to 'lxml' in version 0.4.0. To silence this warning, please provide the `parser` argument, specifying either 'lxml' (to opt into the new behavior), or'xmlschema' (to retain the old behavior).\n", + " d = to_dict(os.fspath(xml), parser=parser, validate=validate)\n", + "/home/matheus.viana/anaconda3/envs/lab-variance/lib/python3.8/site-packages/ome_types/_convenience.py:105: FutureWarning: The default XML parser will be changing from 'xmlschema' to 'lxml' in version 0.4.0. To silence this warning, please provide the `parser` argument, specifying either 'lxml' (to opt into the new behavior), or'xmlschema' (to retain the old behavior).\n", + " d = to_dict(os.fspath(xml), parser=parser, validate=validate)\n", + "/home/matheus.viana/anaconda3/envs/lab-variance/lib/python3.8/site-packages/ome_types/_convenience.py:105: FutureWarning: The default XML parser will be changing from 'xmlschema' to 'lxml' in version 0.4.0. To silence this warning, please provide the `parser` argument, specifying either 'lxml' (to opt into the new behavior), or'xmlschema' (to retain the old behavior).\n", + " d = to_dict(os.fspath(xml), parser=parser, validate=validate)\n", + "/home/matheus.viana/anaconda3/envs/lab-variance/lib/python3.8/site-packages/ome_types/_convenience.py:105: FutureWarning: The default XML parser will be changing from 'xmlschema' to 'lxml' in version 0.4.0. To silence this warning, please provide the `parser` argument, specifying either 'lxml' (to opt into the new behavior), or'xmlschema' (to retain the old behavior).\n", + " d = to_dict(os.fspath(xml), parser=parser, validate=validate)\n", + "/home/matheus.viana/anaconda3/envs/lab-variance/lib/python3.8/site-packages/ome_types/_convenience.py:105: FutureWarning: The default XML parser will be changing from 'xmlschema' to 'lxml' in version 0.4.0. To silence this warning, please provide the `parser` argument, specifying either 'lxml' (to opt into the new behavior), or'xmlschema' (to retain the old behavior).\n", + " d = to_dict(os.fspath(xml), parser=parser, validate=validate)\n", + "/home/matheus.viana/anaconda3/envs/lab-variance/lib/python3.8/site-packages/ome_types/_convenience.py:105: FutureWarning: The default XML parser will be changing from 'xmlschema' to 'lxml' in version 0.4.0. To silence this warning, please provide the `parser` argument, specifying either 'lxml' (to opt into the new behavior), or'xmlschema' (to retain the old behavior).\n", + " d = to_dict(os.fspath(xml), parser=parser, validate=validate)\n" + ] + } + ], + "source": [ + "data = {}\n", + "for ds, named_staging in datasets.items():\n", + " for dsname, staging in named_staging.items():\n", + " \n", + " control, device = common.get_managers_from_staging_path(staging)\n", + " \n", + " inner_alias = control.get_inner_most_alias_to_parameterize()\n", + " outer_alias = control.get_outer_most_alias_to_parameterize()\n", + " inner_mesh = device.read_vtk_polydata(f\"avgshape/{ds}_{inner_alias}_matched.vtk\")\n", + " outer_mesh = device.read_vtk_polydata(f\"avgshape/{ds}_{outer_alias}_matched.vtk\")\n", + "\n", + " row = pd.Series({\"shape_mode\": \"NUC_MEM_PC1\", \"mpId\": 1, \"aggtype\": \"avg\", \"alias\": \"STR\"})\n", + " domain, domain_nuc, domain_mem, coords_param = common.get_map_point_shape(control, device, row, inner_mesh=inner_mesh, outer_mesh=outer_mesh)\n", + "\n", + " morphs = {}\n", + " for gene in genes:\n", + " row[\"structure\"] = gene\n", + " rep = device.read_agg_parameterized_intensity(row)\n", + " morphed = cytoparam.morph_representation_on_shape(\n", + " img=domain,\n", + " param_img_coords=coords_param,\n", + " representation=rep\n", + " )\n", + " morphed = np.stack([domain_nuc, domain_mem, morphed], axis=0)\n", + " morphs[gene] = morphed\n", + " data[dsname] = morphs" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ebc5b4eb", + "metadata": {}, + "outputs": [], + "source": [ + "mode = {\"nuc\": \"center_nuc\", \"mem\": \"center_nuc\", \"gfp\": \"center_nuc\"}\n", + "args = {\"gridspec_kw\": {\"hspace\": 0, \"wspace\": 0}, \"sharex\": True, \"sharey\": True}" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "944c3f4b", + "metadata": {}, + "outputs": [], + "source": [ + "gene = genes[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f817480a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOoAAAB7CAYAAAB6rhyoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAD4klEQVR4nO3ZvUorWxyG8XfFmCCIKKIyEBub2JlCDN6P12DnLdh4A1raewUWFiKCWqhoY2H8aCIqAT8y61SeHY+Jnr13JHmd5wcDgQXLmfx9SGYSYowC0N9yvT4BAF8jVMAAoQIGCBUwQKiAAUIFDOQ/Wwwh8NuNmRhjeHvN/Py0zq8Vn6iAAUIFDBAqYIBQAQOEChggVMAAoQIGCBUwQKiAAUIFDBAqYIBQAQOEChggVMAAoQIGCBUwQKiAAUIFDBAqYIBQAQOEChggVMAAoQIGCBUwQKiAAUIFDBAqYIBQAQOEChggVMAAoQIGCBUwQKiAAUIFDBAqYIBQAQOEChggVMAAoQIGCBUwQKiAAUIFDBAqYIBQAQOEChggVMAAoQIGCBUwQKiAAUIFDGQq1Fwup2KxqOHh4V6fCv5AlueX7/UJdFuhUFCxWNT09LTm5uY0MjKiEILm5+c1NTWl8fFxjY6O6uTkRDFG1et17e3tKcYoSbq6utL5+blqtZru7++VpmmPryhbmF974e0C2y6G0HmxT+Tzec3MzGhhYUGLi4uqVCqamJhQqVRSsVhULvd7XxqazaZeXl50eXmp/f19bW9va2trSxcXF/rsveoXMcbw9pr5ec/vvwsdD0mxn49yuRw3Nzfj3d1d/E7X19dxeXk5Dg0N9fyavzqY38+Z37tZdlpwGPTGxsa3DrhVo9GI1Wq159f8O4Pu9bkwv7+bX+th/TBpfX1dZ2dnen19/bavNc1mU7VaTWtrazo4OPiWv5FVzO//s79HHRsbU7lcVqVS0eTkpCQpSRI9PDzo8fFRpVJJs7OzX+5ze3uro6Ojd/8waZpqd3dXh4eHurm5sbvHYX7e82tlH2o7IYR/hxJCUAjt789btXxdtOYWajvM76Mf9/OMpHcD+ykDzBLm95H1PSqQFYQKGCBUwAChAgYIFTBAqIABQgUMECpggFABA4QKGCBUwAChAgYIFTBAqIABQgUMECpggFABA4QKGCBUwAChAgYIFTBAqIABQgUMECpggFABA4QKGCBUwAChAgYIFTBAqIABQgUMECpggFABA4QKGCBUwAChAgYIFTBAqIABQgUMECpgIN/rE+iFJEmUJEnX903TVMfHx3p6eur63vgli/PLZKhLS0taWVnp+r6NRkPValWnp6dd3xu/ZHF+mQx1YGBAg4ODXd+3UCh0fU98lMX5ZTLUnZ0dra6udn3f5+dn1ev1ru+L97I4vxBj7LwYQudF9KUYY3h7zfz8tM6vFU99AQOEChggVMAAoQIGPn2YBKA/8IkKGCBUwAChAgYIFTBAqIABQgUM/AOJqLuvgXRNAwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for orient in [\"z\", \"y\"]:\n", + " for alias in [\"nuc\", \"mem\"]:\n", + " fig, axs = plt.subplots(1,2, figsize=(4, 2), **args)\n", + " for ax, (pheno, instance) in zip(axs, data.items()):\n", + " ax.axis(\"off\")\n", + " proj = common.Projector(instance[gene], box_size=400)\n", + " proj.set_projection_mode(ax=orient, mode=mode)\n", + " proj.project_on(alias=alias, ax=ax, scale_bar={\"pixel_size\":0.18, \"length\":15})\n", + " plt.savefig(f\"FigureEdges2_{gene}_{alias}_{orient}.png\", dpi=150)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1fd185ac", + "metadata": {}, + "outputs": [], + "source": [ + "orients = [\"z\", \"y\"]\n", + "vmax = 60#np.max([contrast[gene][ax][1] for ax in orients])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7f6f94ff", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOoAAAB7CAYAAAB6rhyoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA34klEQVR4nO3dZ5Bl6X3f9+9z8rk5dN/Oaaane3LYmc1YbERYkFwSACkqUBQlWRLpsmnJrnKVbVXZlu0quWyXxZKqVAoWzQSQIBhALIAFuQtg8+7M7s7s5J3QOdwOt2++J5/HL3oAQhZJSZhZLlo8nzfddaer+97zn995znnSEVJKEonEDzflo34DiUTi3y8JaiKxByRBTST2gCSoicQekAQ1kdgDkqAmEnuA9mf9oxBaMnazx0gZiu9+n9Rv7/n++n2/pEVNJPaAJKiJxB6QBDWR2AOSoCYSe0AS1ERiD0iCmkjsAUlQE4k9IAlqIrEHJEFNJPaAJKiJxB6QBDWR2AOSoCYSe0AS1ERiD0iCmkjsAUlQE4k9IAlqIrEHJEFNJPaAJKiJxB6QBDWR2AOSoCYSe0AS1ERiD0iCmkjsAUlQE4k9IAlqIrEHJEFNJPaAJKiJxB6QBDWR2AOSoCYSe0AS1ERiD0iCmkjsAUlQE4k9IAlqIrEHJEFNJPaAJKiJxB6QBDWR2AOSoCYSe0AS1ERiD9A+6jdwbwlA/v9eU1GERSx7fPe8pCoZJDFx3PkTfj7x0RCAgkAgidDUAlLGmHqRIOqiCJ2CMU6WMi22GI2nuSnPEcuYWAZ4YR0pA6QMgOij/jD33B4K6ndDKBDCRKASSxdNzRHFXaT0MfUhgrBJLLuAiqbmUBUbQ03jBNtEsYMQOgCaksYyhmm7twGQ3ytuEtwPh0CgUkodI4h7tL1F8tY0ppIhkA4df4OsMcQg+wiEjyktYmIGKXFbX2K59xa6sBiIKtgiRVGkySqDdKJNDiuPsKLP4cseFTFJjVUMkSKWEfVgEddfu1PfvVvbH+qg6lo/WWOYlFLEiZs0vQV0NUtKK9MNtwjCNmVrFkmMGzXJaUM01VXcsIGqmOiKTc/fJIodFGGCoqCpNiV9ik60iRe10bU+YukRRW0MvYIXrPNvF/S7J4jdlhm40zrv3aJ/uARC6NjGMFPqaU6YA+z4EYGMWRPbnDGHue60WEn1MR7vZ1BJU7EUlkVIPXYoKzbN2GdD2WRWjAHQF/WzptioaMymUxQNmy82L9GJNsmoFTp0aIVVdMVGQ6MohpAypifaHFefQLc1NpUtloLzKEKj5y3fea8xe6WOQso//Y0KoX3on0KgIRSbnDmBF7UIojaD9gnqwTL9+jSlqMxBq8AbwR+3fDvhIl2/iqWXyWsjDMhxbGlgoeMS0FBaBPgMxgPkFJ2iodEJY25Fm3SUJvm4jCTGFz4DcR9XlQs4YQNFKASxA4AXbKOpWfrNgzTCZfywzYh9ig3/Orpi0/EWEcJESg9VSRPFDlJ6fNSFlzIU3/3+z6N+ikiDUNCUNAeMRxmhzGxORxUQxFA2Yz5oCgIpOV2KqboaW67k2ZEOr2xkudxtU1XX6MQ1NGHSJ0dIyRQZTIYsg0P5mG6ocLsNG77HybzFo5UGL60XeL/TJkYyrGV4V15DoJCSWbqiSSkeICJkQywwICc5Zgxw3a+zKVbI00dPtBmORuiIHqEIWYku44YNgnCHj/LS+fvr9/0+kqAKYZAyxtAVmyPcT0t0yMssW0qNg8owm2GPKSvNmuvRED0qZOnKgGHDRleg4Ue04gANQUEz2Al9BgwTP5aMpxWWuzG6IigYgicHmuRNl5VulhstG1WAEwlGUwFNX2Mi47DpmrQDhZd3Otjo5DWDVhjgE9GnWSxGDWrKBq2oiip0TJEhS4ml4DxprZ8g7pFW++jFdcLYwwk2QcYfScv74QdVYBkjHNAe5oDWx/GiZKmr0g4knxruUbZczteKlIyQGLjSMFAERBI+M7LDYLbFte0Kr2ymSGu7rxcMSdURuJHkYrjKQNzHlG0RSjicD3l3Z7dvwVYVnhtrUHVsLjdMttyYyYyCH4Mq4OXWNmWZpYMHQAaTv73foxtqRLHCumPwVi2iLnscT+cpGpJ2IJDAkB2TUmMuNTRe9N/Fiep0/LU/936MjzyoikiTs6ZQhc4g+7jfHuRANuRCXeVcdBtFKjygT+HHkleis/x05iFMRZI3YsZSLquOxZar0g3hvpJLw9coGiFbno4ElrsqqoBjBY8TlSrnNwepeTqH8m0+aGVoBwqqgIIR8f6OylNDDmGs4MUKJ/s26QUGAokidj/yfKvA2ZpF2ZSYCmiKZNtTmOuEBDImo2q8K6+Rj8sUZZ7z8cscVz7GkJ7ilegsB+MTvBu9SFGfIMSj7s0TRm2kdO/VIf0TfVhBFcKiZB/iKf1hPjnk0A01lns6x4sdxrJNzjz2FudeeRhTD1huFvmglWE21+Hcdo5PjGxQd21ypoephSy28kzkmkwNrVIc3uTG5UO0XRtdDTG0kK/NT/JmzedTgyr3VzZImR6Ob7DWyZEzPMrpDpudHC9XyxzJ97DUiC3PZKlrEEtY7MZ0opC8pvEz++pUe2n8WKFiOVRdm8PFHV5YGeRUqc1wpk3O6nG71s9qL0UrUPFiwaAd8MqGRslUaAeSr3R/lyBq/LnW7/t96PeoQlgU7Vmesz+GlLDjRxwrKBhqxJansT8riVv7KZmCgiG5UI/4H0dOMVtcZ6Wd46GpW7Q6GaydPtwoy0N9bfpSPQAs3UdKQduzMJQSrUAlqwe8sTaCKiQzuQ5SQhQL3EgQSXAijbwB3VAjiHePyXI7TyfQsdWIw/1V3quOkDN8KpbJ44ObhLFK1UkxlgJIYdwZ1ArbB9mQHY5mbda6M3hxwJlyjLrzIL0o5in1MwRxjC8jUuYpTpUULtQlF7nBunOeMKp/2If/rg2lH+XH0yeJ5G6r9RMTVQ5OzfH1C/cxk3M4NbrI/n+ion2tTiHd4dDjZ7k/7XLhq09y6P6LTL9zjO1OlqlSjZ5ncqnWT9n0yJoOpdENOltFat0MS+0cg6kuU31bFI2QMyWDv/rAGww8eAXp6XSXK9yf7dHdLHHr5n4UJP/4F3+ZWy+fIQh3OwhHJpeYv7kPKQUvr4zTCmC+nWM03aXmWggBjwwvc2lziJQqcSOVg1NzhKGGIiT6Th+HhleYOHGd333+0/yVqR4zlSqNbproymc5UZS8tBlwXblEw1vCDzf482ptP7SgamqZinWYPH2Y0qIbSlb8LvusDJ+ZXOCXr09S82IO5AR5Q3Ak7/PQ8DIja2McKNTZ6Gb49kYamOZsLU3ViRlPK1yo55iJNLZdkz7LY75jU7ECOoHK9abkUF4yW2hyuV7g+ZUsY2nwIoGuQFmPqXkK890AiUFO373kyushthqx0LWxtT5yhs+3qznqfowiKoylPOY6JusOFA3QFYmlSJ6oxKw6eUbsgP+1Uuat7TwrPRi04XIz5LF+nXVHp+FruFHMkXwbVWS5X8xwsT7LN9yvEcYOcewTxc0PqxQ/kKx1gE8Yz/DPfuJlUqXf5+K5UyhCoikRpu1yoLjDmQfe5eK7J1A7K4SNDLMPnUc/FOGeeZYTT64SZY7Sv7RFLAWqEnN5Z/cEerOdJogHWX6lBMBwvgHAfCuPqYY8MLhOw0lxe2mcN68d4f2dPKYas+GqrPV2b2v2Z2H6ldOs1PoZyDe4Vh2i1UvhhTqldJsDuRY112bH19lf3qRbHWEsX2fm+DVKSw0unT1Nw9f5zqUTeLHCXDvFQ5VtPN/g23/0BC3f4OTULXK5NmP7F/j41gDjmTYpNccT4Wmc6Axv7DjcVK6w49780E+6H8Klr8pY5nF+JHWImic5F93moJwkkhJHhjw7oPMTh64SRiq1Vp4XV0YIJPzl2Rsc/Z+X+dY/OMrL1QEavsCNYDITUTRCVnsGlip5d0cymd69zP3J/Yu0XYumZ7Hp2lhqxJMz13n11gyvbqQpmvB+wyNCYgqVlKpyK9pkUuln2FaJJWR12HQlzSAmpSocKcRMZ7tsuxZrjk4r2A35B62Aa8otHtUO0m8JGj70m5L0nUP06OAmf7gywKG8Q9U1OZhrUbJ7LLfznKtlUAVMZnavAFZ7GqoCzzfWOawOcawY88u1W6w65wmj2g9aS+DuL32FMPhU6m/yS09dotHKkk138QOdrmtTKdW4tjxB07NoBzqzxRoDxR1m/7PzoBtQbeCv5tCeHSF+cREl7XL9hUdZ2Bpgy7W50Urx2f3zzBy9RuBYnL90hBfXBni4v86NVo6y6fP5x1/hhdcfYdu1mOsYfL29QExMIDwyMk9PtOmPBimKFPszOluu5EAOjhbaNH2DyWyTXmDQ8E3aoYYCpLWQC/UUB7I+W57GA307CCGJpMK2YxPf+ZnP/dRXuPHaaa5VRziz7yZ22sHOdWhulajVSpz8+deI5uF3f+NzrPZStEOVM301Fts5vram8nr0LdruzXtWv+93T1tURaQp2NM8YRwip0tWezGGNEirKh8f8ImkCsTUWnkUIRmtbDDRKDGeaWGZHrw9z9mtJ/nd+jKPp8ZxI0nVUek3A/rNkGPlGq9sFSgYgpQa03JtGp5F3TOZzjfoz7TQ9ID5jo0QoApJD5+O6DJMmcWogSdcgjjmasdj0krR8CUZTaAJQS+K+eamw9ntFKdKCv1myFs7EQ4+I1qGiXCSZyc63G6naQcKbix4pFRn00mx7aQ4Wuix6ZqoQlKye8QIuqHG56dWuL7ThxOp7Mu1uN4q88mhOqoYYssVTKYdnmjPMt03zZtbkhecLxDH7XtZmv8gutbPX8v/JZ4daZAtNggCjQtLk/ixypZrcvP6FAfzPgBSClY6OR76xCugGzj3fwbj13+bjSv7KdY3eeW1zzAzvELPtblv9jqLK6OktSIjQ+v81otP48YKJ8pb/L0z7zH5qXN85V/8NFuuza++9BRvb+ls+j4pNWKGUVZkA5cejuixEy7SUWrMA/PdYR4wJshqEb+9mGExajCrV3iwP+BGy6DfjDlRajCSb2BrfaS0gF6U582tMn4ETw9vogrJlUaaybTP8jtHWdyuoAiJEJL3P5jhcr3EOzWNf/jgVcLbgtgxsfWQJyfmyWa66IaPsjDFz5omP8uD/Kvbj/Oy+8U7Y/n3zj0Lqq7186j+HEtijXYQs+budroUKXK6EjGe6dANdLZdi/Obg7yyYTCRnkBTYCTdwQ8Mrv/hI2S0mMfscQwFFAFbruTkwDq1boa83eNv7kszmqnx4NOvUr26n5srY6T1gGovTc5yuL44we22oOYHNHyVomKzzDxNUWMoGiNFhvfFRTzZ4aafoswIhSAHQF6xcIRPR/a4Wm/xuDHNmYLGYtckowkKhs16L+R0eYcPmmUiKVAVySMTc7xwa4brLY1VJ8CRIaqoMJ7u0Qw0hsrblLItbm0OkjE8bBWqTgpDkbQCONi3we12isl0j6xmMt76Wb7VXeJG9+v8eQ0VFOyj/FzhcY4Wury2WSB95QhPf+7rRC8rbDcL9MIy/ZaKLiSBFBQNn+nSNls3JhiZuYyxfg1nucKluf3cbzuMl7d58cYhVh2Dpz2L1XaOWApW14cYSXe43c5xYbvCcjuPZbvMDK7x+qUjXGi4hLgEhJhS5Zq4TdW/iqGmKWkTAITSI62UaVDlspdBb/UxnZUU3BJFE9rB7tXSqqMw5KTIGD6LnRSfO3KZjOGz1slypZnmg2aRT89cY/nKUbqhwrdvHOSvfe6rzL93mCDQWetm2ZfpUDJMMpkuN185w8LWAFLC8MgavU4aISSPP/My/9dvfo7JtMNj/Tr5+s/ynfBVGs4V7tU97D0JqhAGU+ZDDBsmujeGKgQlXSeIJbpi8ujQMhnLwTI9blRHODK2QMWa5s2tPEEETqCTSXcAmC3UOdkX0PItcoZLjGCwf4vpA7d55/1jtHyD35oboZQ9Sb2T4b3tPspmQDfU+P25cQIpUAXUZIe1yMOUJmUxSEPU8ITPCtdpOgsoioGn2GT0MutqD0MapOQgFbLcEsvYMoWmwJlyi0N5nQv1FJdaLoqwqFg2eUMwmwt4Z7vIua0S79UjTCXm6QHB0VIbJ9BZc1I4oUIcK7y/NkYn0Hl+pcQFZ4dOWKIXSrZ9H4mgzwrImy6nxhaoXj7KX7VHuG3+PL/R+NUPvXXN24f5PyfP0Ap8xrMt8rrPiQM3iD0DQw/I2T0OIPhbf/ObxJ4OQtJaGCaOFLyejXOpxNV/3ce/ufYgw6mI1vnTpHWf2x2TlCr5zdvDtALJ6VLEjbkp2oHgr87Ms1gv0Q51Lt2aZr2XYbUnWVe2ycU5NBSasYurdBgzTqGgoEoNtAlc2SHEoxfWWFFDFPcwB6IiC36Lfi9FKCW+DCjpBm6scLVeYjTtMH76KvE5hTMPvMvBi4fY7ORYrfXz6cl55nb60UTMiy88zf7KOiOH5jjZTdPxLLqhTquVw/N1BrJNivkmuX/1N3B/5ks4PRtrdoeyEaIpMQdzbcI4R9D4GG+nTba7F7gXJ9t7EFRBOXWMfFxgPL37K0dSMGIHHCzuEMUCISSXN4apOhYz+RY9x0ZXIkIJhrLbumzulJnb6eNmO01Wi7ivf5MdJ8Wak2KgsMPF+f1cref5zPQtqu4M1UaBlU6OshlwtWkzbIfECK62fOqySw4bT+q0RId1bmHKDJpUsZQcdekg45iSuZ8l9ywpvY/j4lGaOEybOdygg45Bw5e8vpWnbMaMpwMUYaEKsLWQVSdiIi14fdsnpWjUY4fTmSzdEN6v7f7HWOwYPNzfYGB8jfcvHCNnxExlImpenh8bqzHXylF1DV5cmuC+8jaf/O++Cdkc039/H+/tpPlbs8tMrvwM/9vKr97zS6nvVU9Y/LN9ZxjMNLlZL3FgfJGhB64gP3GCr/3cp7ndzrLhaHx6rMqVP3oEy/QYGF/DzPTQs13qc6P8i9/5cWq+xomiSydUeXcniyok852YJwdC7u9v842VMn+0EWMpgoKu4ocaDx+8xuhPXuP//Z9+mhfWbEwVCnGeomKTVlWcKKLEEOk4zQ15Dlst0g6q+GHzzgSTgFBziYwZdoKAqrpKFZiIJwkI0YXJH64rlAyV6azG/NljzH7+dVa+eZKGk6aU6lJt5+jLtghjhZQRsNrNsHh7hqeAEz/1EsIWfPV/+LsMZ/JkLYd9B24T+jpy/XXG/vptxHP/hJW/vFubv/QLX+C1X/tRbD3kZrvErH+cY/YpXvF++647C+86qEPpR/ikeZK8AQU95CW3R8HI0QxUAAwtou1a3GqludiA/VnBF64eYqUHj/a7rDkGbqRwdWuA5Z6FHwv+qArdaJCCHnGlaXD+naPM9VwOZjRW6yWe2zcHwEYvQ8M1cSK43dGoeTEAV6NXyOujzMZHdu9Jox6aarKj1vBlj5J9hBl5nAVukTfHGWQfrvRZUxa50lukYsygSIVXo3cYaE8w1ilRNHQUAbecDleaKS6KC1zZzlOTcwxzmAkxwOWWS4ykh8vDuSLDdsh4scbizSkeG9xhqZPh0dFFBu1Rjk3MweI+hMiy0DHYcVNENyOUQpWy5SJI88b6EBUr4JOpn+GF7r/kwxgKmEl9itFcg9HKBrbuk+uro/aF8M47XGueIpKw0JUEkcK3Fvbx5rbK0StHAfjY4AajfZt89vgFhCLxPYPra2OYSparTQOQqELy5maJh/q69JkpKlaAF8cstQqUsi3e++eP8S8XQwbVmFoQMK9c56b0yMb9+DgEuGQ4jKZYbPYuIFCxjUGCqIul5VGEzqZYBgmFuExNVBkyLCx1t0/mP99fZ6OX5nrLZnGrgvMbTzMyvsIfLA3yqeFtrjXzzAyucbC/yqsrE0xm2niRxsXVcaq/8uOM9m0ykfG5VOvjJ06cJ/cLedTNVbj2Fs7T/yUpoLx/BeviSeKWyUBxh0Eh+XgnQ4zKJw5c55ff/2v8H6v//K7qd1dBFWg8Y55kPB1zKN+mFRhU1VXebQmKHZsNdxBDgXYAeV3ySH+IG2nUfcHRQkhGDxgBpnINrtbLpNSYYTtgKiPJagF+rGKpBjUv5kTeYn/GZ6y8heNabLTzHBtc5cWFfbR8iRBwLapSE6uowqThL+FpM2Rkjpy4nxZNerKFLfIoQmFDbmKTY4BxNsQSOdFHO6pia0X6o0EaSh0VnaLMUZVtVryIp/J9tIIUr8dnORqfpCF6mKrFjBjCkzHv8yZdf50R+zSXWjaWarLaLNLwLNxIxY0UXlzYx2yhyZXFKWquRTtQ0RXJK5tZ+PWfJGd41NzdOcVnawofr0ieGwl5a/kIDefy3ZTr362fMPh8cQQpVxk+dpPsapPM9Arhqs0f/u5n2J/p3KlzBkVIfuTgVX5USMpDm3idFF869yC6GnLkyDWaWyVUNeL41G2emV2gPjfC7aVxFCFprw8TSMGTI+u8tTHATK7NSjdNo5PlxeVRmsoKTxeyvFGDiXiWVWUBV3aouTeBmC27j5IcxUxlSFMAYCl6l16wSc4cpxWsMaBNEBEiiVnzHQxUtkWTQ/USk+kuKdXCjzWubA4xMLDJf/PoWSqzCxy+uo98/w6BY/Ej2Q5n56Y5MbrIb145wlI3RcszqVguBdNhdWOAoa++ilLucP7Lz3DoxC3kS/+UN196kuF0m8U3TrL/yXOEjTSPuBaKIslkO/zCQ2f50jefZrHz4g9cq7trUYWGG0m8WLDQTePHgtNiFjQomwqagIYPZVMyaIVUbJdICvwIRlIOqpCMZ1tMj6yw3s0ykOrwxmY/hiI5Or6B6xtoSsyXFzN8q1WloFdwPZMXFifJajG2HnB+R6MehGzSZjE6T89bxtQHiGKPC+GLqIpBRZ+lHW/iRi10xWaak6go3BKXWPLeIm9OctP91p0lUnBBWSGKu6iKjWrrCBQUFOY7JQxF8EntQfpMQV436IZF/qi5hYrGo8pj9IyQB/Imt9oSPxZc2Cky31EYS0nKZsjVlsZMHgKpULZc6p6BEyl8t0++YPdo+CbDdkhK250lUzQiHtce4yvc26CqSpbxtEsvMLj59gk6Tgp7cZSU7RBJQcbwcUIdS41xI53tZoH9k4sUjs0TtWw+eOljnOoXtLaLvHD1GLc7Jv/tJ75N2LG5cHOGtW6GsumS1SImsi3CSGG+o7LlFjiQ9TjxwHu8VR3CkikavuAnRhRut3O83ZogJiZtFelSx5Yp+uMSG4rGenQdIVRiGWBqJQQKBX2MfpmjKR0KokJLdPCFT39c5oVqyN/dL/jc7A2+eG0WTUD3/GkOFOrs7BSZmr3N62fPMJhrMLfTz/mdDN/ZOMofutf4xco0t9tZ7uvfYmJgnbn1EaqXDtA3tUrLTWFdew253EIISd2zCQKNncv76DRy+KGOG+j0PJONdo5DMs8iH1FQFWGyEwSMxAYrPY2GL/k7M5tcqJUZsh3O1tJseRGfGu4wkmvsjiG28qgKfGs9y4AtqXk5rl5N8dfHVFq+xSOVLd7Z7uMLN6ZQBdT93WGWnMxwtNji9dVxlrsq647kcFEwloZlL2BYyZFRnuJ18YU7K2AU4tgCLQ9AJ9gAwAk2uWnGZNUKXX+LMGrQCTaQsYNtjqIKHVWYNN1b2HofrmzTCTY4rH6cGh4V3eS54S6rPZuvV0MiYhylx2Z0i4x4FB2Ff7r1PLZW5JfKJ1ju2ez4kv1Z6EUKm25Ew7Pos3tM9m/Q9Ey6kUJGUxBCkk93SHWyjKYdRqRgwzWJpOBIXvAHbQ1JeDcl+7fkzFEyeoAbary1NMW5ms1L7i0+kz7JU4M7+JGKKmJMRVJzLV6ulimvjnL86mFGCjvsy4Q8/GMv8jtf/Bx/5299gS//xueZn5/kK3OTWKrk8wevcXV9lEAKtnppglhhNheQ10Mqdo/0AzU+/t4yTjTBWg/mOwYS2G/s9sJ3ohw7UYWO6BEQ8mxulPcb/cypC4yahwAIRUguzqErCj4BA3GJD5TrDMhxDmVs1pyI9+smLX+SsZTPkfIWYazS8kyW2jlublcoWg6m4bPU3e1A1BX4B4P7eWBwlRu1fqbHltC0kLpr80dXjnFkYwBVxOx8IYWZGSFn9Ti3WeGAY3Pp/H1cbmR5uLINwHY3w0Inw1hKg67KD9qxdFdBlTLkYNagG0JaA0sVXK2XMBTJ5UYKN4L7ioJOoNPzTVQlphUY7HgxpiJ2Z/iognEjTdWVqEpM3TMZS7m8sCkZ0lOMphT6TWg1TV7bzFDzJGkNnh2OmGsVsFVJSuhcEbdxlBaqYqOpfVhqASfcIWsMoUgFWyvRcucRQqPtLtLiFrpaQlNLSBljGcOU9X1IYgxpE5sBQqg4YYOiPkFRpplMGSz0fOY6KTQhqSqb5OI8DxgT9MJx3o4vkqOPMHDYJz/OpUaGlBazL6Oii5A+yyer2yx0bd7ZSVOplRixPXqhgqqApYZk0l360h2u1voZTXdo+AbdUGPbE/c0pABtfw1VHGO1l2a1ZzCejviMOs2RvEta3x0vHSruMOik8AIdJ9Q42rfJ9MQi2YEazV6a5bePcaC8ybtff4K6Z3Iy3eHH9y3wj8+P87FGCUVI/EjhOxtZqm7EoKVyrtfkPruPqX/zKB9sV9jxVFadiNmswnJXshp2mFeuYpCiKCrEImZUT7Pe273H648G0VHpiB4NNmgp26yiUGaQgJgTHGVOrKGKEpGUzLVhqWMynZM8bPc4+uyrSE/n+ssP4PoGp37024SNNOv1EnOtAkXD4/joErO/cIXmP3oS3QgIQxVLC3lw5jq1WgldDamuDJHNdth/8BbZdBdNC5mUCvdNzrG23cd8o0TZclAViR/B3fT+3tVWLLF0GbQjdjxJSpXkdHhlU2Ek1eOVRovLvSZHiy22PIOOb9DxTXZ8HT+O8WJJvxkymQ4YTYMb7U4OALjdsRk30hiK4I1mk6IZcyyvIdg9GfRCKBg+O75O2QzoSI+t4BYAo/YDGEoaW8ljqlkAmrKKJEYIjbQxyFj6YUbTH6NoTqIIHUXREEJh3TlP1XmfLnUG1RksJUdOG+SoPMKAqbPqhHSkx1xbZaGrMRhXOGLn6YaSxyoRMRFtdhi2TpAXNhfqITdaCrH844Od1gTbnkLViblYF/ixQjcUGIokrfuUx6oM922z2DUp2D28WFDzNGreve9ICsIdNhybGy2TC/WQw/kWf/vIBzw0ukgh1UNVJGMH5jn11BsMlbcZz7QZrWyQKrTxuzb5VJeteomRkXUUIXlm5hqOazFfL/MPju7O1f7GaoFIghvBWErleNHjpypF/ovjN+ivbJHRfUxVUtBV5jqS7dAjIiKWu722CgoDcYk13+HdcJF5dZlVZZ455QN84aOgIlDIUmJcKSMQuHFITMyrnSqbcZtISiq24DOTi7ScFOeff5L5N08wdfQ6iohxlitsXN+HoUbMFHfImR4XViYIzoeoiqTbzuB0UxhKSGm0Si7bQRGS+e0Bbi6Pk3+uw77/xaU0tMXM0WsM/1I/m90sq45FOd1BFZLgz5gB+B/iLvdMivjtzTpOFBGzOwd2Jqfgxyr/9X7466MWQaxQNn1qnsWv3Cry1apLTldJaYKhVI/TlQ36zQhTkbiRsjt5wVGwVIGlCj43mMaNBHkj5tnRKj81WcVSYcszqVge15omHgEVfZaJeJZ6tIymWJgig60W6QZbmCJDEPcYsI/vvibrbPu38OIOppZlwDiIH7YBhbI1S0TAtlwikLu9jvNilVeD6wQyZlBLIwT0QjiY2V1dM2ApXKzrpCnysHqMJ81ZLEXlmnKLl/z3WHd2e6NfWLOpWDFXWy7//elbnCpJ+iyXz02u4seCa40SF989wa21YSTQdG26oUovErwRvX93pfpT6vfFVY/xdMCQpXOjlaXWyVEsNjhw6AZ+pJL9bIw+0CKV6fLw6fdQ1Jhfe/Fpfv5Lz/D26jiW7mMXWoyNrlLo26Hn716qpwwPRUh+anKDtBYzmYkpGZJbbZPxdI8g0vBck2Pjiyx0IIwlbhwzm7bJYXNI3scD6gxd0eE8b3JJvoGKRi2cY9u7gRd3sGWKg/EhMhQYiPtoRB4SiSoUUjJDU6kxqGQ5WZL84oPvsNnJ0XBtoljB802uvXeccrHO22/dj2l59BfqFOwuN5oFFjspfv/LP0bHN1jd6md5a4BCqsf7506x7/Nnubo1yFeXy7y92U/ty0XUa5eIAo3lm1OY33yebdciluAFOpEUvBJcvatK3fXmZhd7X+aKuI2lxgSxYH/Gox3ofPanv8KPHLmIlAI/Uql7BvuzgsdKaQ7lY47kI7Zdi5uNEgtdjUgKgliw3rNRBHfmX8LttkY7UPj2ZsDzy4OsdrOEMSx1DUqGh65ALCSH5SQ90cMJdkgpRQpxCRWdWe1RDJFCoKILEzdukRZFJvXTtL1lut4aXVknYwwhhEIvqtEJNmg4twhjFyljinGJ48zQb+j0oojFnseAJfnRsS2G7JDJTMi6GxCJgKwuOF3yuL+8O1zwhHYff3d2k4rlsz8LHxvYZMK2kFJQNgL67C7lXJNeKDi/Y/A7c+Nc2ikznvK5tFNkpafwWr3DeveNuy3Vn+is+5v0mz6fGm5yoa6y1slipXvkP+diaiFRZQQxXiLwDNKDNSoHFnlm+gP+ymST+wbXOHD6Er/0/LP8wTv387e//HG+sTTGieFlat0MthYiEXxq9iofG9jE1mKKRsz+Yo1yoc7wqetMPHqeB8ohqgJZTaXqRuyIDhOWzc2gTiQCDnAfFXWa4bifAXWGfvMgk+IYHdHipnoLR3RZUlc4GzxPW/RYFlVc0WMsmmA8rVHzVK4uTTJe3Gahk6VSqqGqIUGk8rUrxzl98n2q6wNcWx9ls51jLNXl7//slzg9tTsMuNAsMlzaputZDJZrLPzeafxod/ZTnxnQbWaR7ZDt9QrvrEzQvTpCECs4kcJ6N8uttsFK5+W7qtM9mPAQsdR9hevaDKYCW3fGG9/82lNMTyyy6Vp8ac2lqNh8dszhwbEFbm0OEkmFhm9QsR2eGXKpeRZLXYuzNbDu3Lt2AkjrcKsdIhAEMTy/YlM24YFyk+nKBl9aLPBcXwFVSFqbeZ61P0snClkRm8zEMwgE26xjawU6cY2sWqE/GqSrdLH0Prxwh7a/jq2VSOsDpJQiGbWAb/iMRMP0qxb9lsJyL+S6X+ekXSKlga3FvFztYzztc3bT4IJ4B5MM3/FuEdWm2fJCPtvXx6YraHoW3VAjr0cMl2rs2+rn3NoYh8pb3G6U+LVbI2R1vreQOpBi98QlBYs9n3Pe7/FhLaeS0ue/mn+dX+x/BoAL9QxTt/az83832ehmWPqHgr6xNJeXpugbXyfzaY8Dz21h/O8+W/USkWtypNDiV25nqMcu15sp5rcHGM3voHaz/M7CIKc7WZqBxqlyDUONaDgpXrs0yhONAqee+xafnL5BbmmKrywbLMptZrUKV73d3RhUdPYbOUbTOXQFzPooKVXhQrRAWmYYiCusK1U67C5mqCtbFOIyi/FFnsk/QxDDpB1iqCHvrI3R8DUWqsO8Vh3gTF+No6Vt1pdGSNkOq70UR0sOP/GPXiIuDDKZe4et3y8yJCSpdI9oWzCwf5F/8Qc/wo8dvMqpIZtjP/Iy7/3B0xgvH2V5u8JIuk11boy5jkFGk1xrZvh/du6+fvdkCqGUPl9q/grD6fvJuEfI65JX14eY2TdPn+UypKXJ6wqj6RrvrUygCMl0aZu0kyKl++TsHrX1USIpmEgr1FyJpULdjzlVCrEUnXcaIQNWzP5sxInyJq9XK3xzLc/+rKTu39kBQGgMWAqho9IflUmrOs3I51A8Q1322FDX8O98Tcksj6hP8+3wt4lihyB2MNUMEQG5OE9baWOg0o0i8pFCO/apq1vk9BJOBG9s7w7lWKpOMwjxZY8zyik8GVPzQvZnNAYsFz82mW9n0BXJck/j9z44yJDtUfMMpBTUPINWEFOxBLYKdV/gR4JapHG7I/iO+8UPfQph273JP17d5D7zOa4HLlNbA7A1QF4PmK8OYdoO5VQHv2uz9VsZigeWSWc1vnrlOGnLIWe4zOQKKKQJpUBXIq5sDpEzPJ4dqaEpMXMbfagiZnpsidsrY6w5Gg0nTe3iNKP7ljjhWry5tZ9BMchUJmLQKdHwi7zjLxMDWT2m5SvEUnIhWqAc96GhMJtOEXcrBKrHsHWCZlSln0HGlKOs9WLSmsKJ8jZPfPYFvvN7n0Zhdx1zSo15e6vMG9sBT1QGOdO3zVS2jaZErP7KMI16gcqQoJhtkc52qO+UeOCBdzH7G/SbPtWdMgDKbB6BpNPOEMWCvO3w+twBFAHv1SNedL981yui4J4vcxPsS3+a09oUaU3wyaEmkVTohhprjsknx5e4vDXA/kKd4dI2X7l+mIavciDr0A413q0ZPNTn4UYKV5o6xwoBoYQvVts8kd9du1ixQsqmz3zHZjzl0Qg0hm2Xg30bvL0++r3J/zdaGRq+QiRh25Xc9ltM6DkUAeei20xFY+hCYUGsU41ukNOGyMdl6mKToqxgS5sz2Tw1T3IzqNNPliN5nUjCUjfmSrxELs7zXCWHrcZcbuhMZyOyeoQfKRhqTL/pIYRkvpPmkxPzKEJyaWMYN1IJpMAJVRqBShCDlNBnRTR8FQl8Z6fNO+5v/0fvKHB3y9xUbGOEz6Z/lKmMxFIlP/fQm1SrA4SxyuTUAt1mluLwJka+y1vf+hhzzQJnt1NMZiIUJM1AZSbXw4tUJrNNbD3g0OwNOo0c524f4PET73P26hFerpZ5fLBGxvAYKW8xtH8JoUbUVwZ58/ohtjyLvB7wwlqaYRs6oeBw3uera3BNXGc2nqXD7j1pCpNbyg1m41mO5k0MRZLVY9Z6uzuCjKQkPzq5RBiphLFKNzDwI5UX1wv0m5LxtEs72L39utLUeKDscbNt8mMTaxycmsN1LCaeeQd3sUJ7vY+vnHsAXYn59Mn3GPz0FS7/+uNc3xjiciOLAqiK5Pe3mrzv/A5S+j9w/b7fPV44LpnrfoN5YXHa+kkOdNKktZhepOyewdZHOLut8Zc+8R7d7QJBLDic76IpMQ1fp+aHtEOVg/kmIymNGMF8J80D6RJZLSanRyx0daqORl6PKZoer29ZpLXdFf5HS9uMVjaZr+4etIwmCSTsz8J+cszkury3k+HpcBpThXdbbfKygK9N4sgms1oFwQB5Q9D0JTc7PrGU5EiR1lRutiP2ZVR6UcRz+QnmOpIghmcnFxlJVbjRyjCS6jFe2KHjWWx10/ixihsJhoeqpPsarLcKWFpI2nSZ2+kj7tncamsUDUkkBSs9+Jr7HZrO3XU+/GAiHH+JLwb/hk/5f4NjBZUrt6fpBTrrvTSxFExNLaCnHdztPKV0m9V2jgPZkKWexo4nmclJHp68jRCSyQcvsnj2GO9dPsJCO8+A3cPp2rxaLXGy2OHrK2X+8r5VwkjlvbP3cezYFXzPJGd6XGtmOb9jcqoUsNjVWXciMppOlQ2eNo8TScmrwRyj0RhDhokeHGQibTCeCtifazHVt0Um3eE7Hxxm1TFpOCmOT9/k5uIkk+UtJg7eov3Sk5waWmGzlWe+VeBgaZuiWaLh69zuRHxjaYj+XANNjSAW9Gp53rh0DFWJqdg9UqUm7gdFrm8M0Qp0rjcFG4HLe/G36HkL97QyH+KeSQJDG2DKfJAj6jDHi5JYCi7W4RNDPvcNrvG7t6d4eniDtmdSsB2OH7nK1958+E7Pr42Ugmaw28Lk9IhDhR2+uTrIew2XgxmL+0q7M2hCKVjpGTw2sM2Oa6MKSdWxONG3zWYvzYZjk9ED+i2Ht7ZKpLWYlZ7K291t9qklGqFPiERHYVXZ4BFrHCmhE0oKhmAmF7DtaWy5AksFJ4QfH69hqiFZy2W+UeLF9SyRlPzU5A7lVIcXFseB3b2WGr5CvxXRDRXKRkjR9CmZLgXL4cvzo7zUWaHGCk7YoOstcDfjbfduzySBppY4YH2cx9PDxBIeq7TpRbtL3a63Ujxc2UFKGMi2eG11lLqvEUn4+QfPcW1xkrZvcnrqFrlyg+ffeghdiXEjlScOfMDggQW2F0YAcHo2N6rDeJHGZLGGc2corxsYZA2Pl6v9pLWYLVfldKnLfMdmoatwyd0hImRG6+ehvpDxTJfjYwsUKzXqm2VyhRauY1EeWyfoWbzxzmkavsmZ8XkKpQbXb+1ncmSVleogMwdu0dgukSu06LbT7DQKLDdKHBpeYaNeYnxwnfXtfnq+ScHu0vUs7n/sbV588XF+9XYRRcDX3a/i+qvczf3oR7q5mSLSlFIHCWOPB8QjTKZ1+q2Yy43dXXMHbYVPjdT49nqZ+U7ET070qHkmU9k2h0eX+PKlY/z4wWu4nsm1zSHO1bLoiuQTI7uzjdY6WfxYYTLXxI9UBrJNXliYQhOSQ4Umj5y6wMUrh2m6Ft/ZKKIrMJ72We3pbLuCnAFlc/eStRkI9mUCxtMdVCUma3qEkULdtan7JrEUtILdS9flrsp9JRdNiflXi7v3rBN6DksVd4YbJGthh7KSoh37HEynyOuSDVfQDWPelR8giVntvnXPNs36MDY3U5QsplbEUDOMikM8kh7EUsFSJWfKTT77936Tf/1LP8dgqstEaZtspsNCdZjTZ94j91SN8IOY+gcTxKFGq5Fju1lgs5PlxOQcihrT6aQZnljB66YIfJ2ltWH+cHkUJxQ8UtldmD/fNekzQ54aX+A7S5OUTR/1TvD35Rv05xroWsh2s0AsBZVCnXo7RznfoH+0illo017tJwx0zLTD+vIwnm8wOrqGlW8jFMnclRlmzlzk6tun2OzkKNg9Lm8N4MYKUSzYn2uxr3+DgeEqL717hi/Mp2jFAW96v0MUt7gXHX4f+S6Ef/w7LTLmGLqSIpIBA8p+VsJLjGknWA7fZ1A7xJP2Pg7mAl7aEOQ1ldE0HMr3WOzYNAOF250IS9mdS5zRBVU3IqUqjKd372GbvkZO322VHhxcZ6R/k82dMk3H5larwJnBNWYO3uDy5cNc3q4wna+z2M5TsXtoSkzB7nHykXOsXp3m7flp1hyLF6ohfbrBVEbQDgRXOj0MVNq4pDDZULZZDt9HEyYj6mFKcYGQiKq6Rj4u01RqTMdTeDJiTVln2XuHINy614f3Q98uVKAxmH6Qw/IweU3jYE7QCQWXmh5nSgaTaY9DpW22ehlUEXNy6ja1ehEpBaOja7x77RBbrs1Kz6IbKsxkHVYdk4cqWxhqyM1GidWexcU66MruWHosdzcRmMlFWEqMocYM2g5OqHFyZIkPNoYZzde5tDnIQtfiEyNrjA1U2dwp44caB6dvIaXC/OI4W90sT378Na6fP8pGO087MPithTSnSoJWoNC9M/nrU8M71D2L6y2bdrB7SDOa5JVGiyE1w+vxm+z0LnKve+N/aIL67/wNNCQRpj5EGHUp2tPYIk8tmEOgMqDN4AuHfdF+riuXSIkijmySpcxAXOF0PsXz7TnSMsMQRfZldPwYCrqkbEYYisRQYyIpOFTYoT/b4vz6KL1IpWT435sNteUZNHyFtLZ7qVrzoOr5rIltNKkxF72HF+6Q0isIodL1NzC0LJowd6cdKhlUodMOqmiKSSQDNGFiqBm8qEXXW0MI7Z6def80f54bcAs0LGMYSUxKK6MJk5QoMhQNMpvKsOVFBHFMydCo+SF12SOLxeGcyYudFY6ow/SimFW5w0mrwuMDXb6xmqIdhgxYOmUTslrMQlehYECfGXG2BsO2ypYbc7wIg9ZuZ007VNl0Nd6qOxzJpBiwYjJ6xEpvtwPQUiSdUOBFMJSSXGnEeHGMKyNUBIvKKjOME0lJjOTnp7tcqOf55nYbFYUPeA83atz1pe2/zw9tUP/dv2mhKjagMGKfIpAePj0MUlhkaLGJF7UoaGOE0kOgUPNvI4SCrthMKfdhSgNXuHRFh/64H08EnE6VaPiS2Ry0w92tQ3e83c6gq9E6wO4mWvg8ZEzxenCDdfcyQbSDqqQBhbQxQC/YIopdMsYwofTIaoNsdN9GCB1TrxDFHmG0u0h4dzXOf2obcP9Zdp8vI5FkrX04wQ6mVgAgrZXZdq4hY4eUOYEqNCrqNNvxIi1vkT77EKPxNCksiqpBJwqpGAaqAuuuz6ht8lCfixcrdEOVGy0VP9pd3jiSghutmGtymVycJ4ONLnaH7B4pa3ix4FpzN5iBjFlUVlFQ8IRDJAMiAmyRJxvn8IXPllygIIZZcF77i7cB9w9mt/AIDSF0cuYEkfRwgh001UagIIm/94wZQ8tjqjn8uEMQdRGoBOE2pjFIRh9AQcWJ6mTUCgCdaJPOneeQ7J4cwNRKxDJACAUpY8LYoc+cwZMdUkqRdrRJEPeIYp8w6iJl+KHtvvCD+GiD+qcTwsDSBwmiNiP2aSJCLJnGEw4KCqfEATbCHjGSqrpGID1S5OjRwhApfNljX3yAiIiACBUFBYEjdlvUBXmJfRxHR6OltNGlQVlm2Zc2Wej5LIo1UjLD7egd3GAbS+9DU0za7iJS7g7z/DA8i2aPBvXPJoQBMgahATFSRuhaCUXoZPQBGu4cQnx3luTuA6LiOERTLTRhEkqPWIaEkYOupoliH11NE0RdVMXAC2pI6aEoaWLpAArI8If6yWA/rEH9t+3u/iEQCMVGVSyyxjCmyDAZT3NDXKQTbDBp3E9EyLJ/nlgGRLGLpqQJosadljtAyghTHyBvjBJKD/fO1UwsQ1RhktMGqQeLSBkTxd6dJ/99uLvd343/JIP6p1MRQv3eYPPufbBEUVK7Z08Z3HnA0/cX7E86Pnvv4++NoP5Z1DtfdzsDNbX8vZOoEAqmmqXtLQJ8r35CWCjC/OOT6Z2T9l58TupfsKD+xbX3g/oX258W1LtePZNIJD58SVATiT0gCWoisQckQU0k9oAkqInEHpAENZHYA5KgJhJ7QBLURGIPSIKaSOwBSVATiT0gCWoisQckQU0k9oAkqInEHpAENZHYA5KgJhJ7QBLURGIPSIKaSOwBSVATiT0gCWoisQckQU0k9oAkqInEHpAENZHYA5KgJhJ7QBLURGIPSIKaSOwBSVATiT0gCWoisQckQU0k9oAkqInEHpAENZHYA5KgJhJ7QBLURGIPSIKaSOwBSVATiT0gCWoisQckQU0k9oAkqInEHiCklB/1e0gkEv8eSYuaSOwBSVATiT0gCWoisQckQU0k9oAkqInEHpAENZHYA/4/WSjNSw4bGj8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOoAAAB7CAYAAAB6rhyoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAANsklEQVR4nO3azW9dZ17A8e/zPOflnvvia/vajpM0iZu0aUOTlrYT2jIDpaOOhIBBIITEjg07WCFYsucfYMeKxYgFGzTAdACNGKYV05lFO6EkzXtrN7GT2L72fT2vz8Pi2m6SJk2ipso80u8jRbHlc895fJ77fc65J1HOOYQQv9z0kx6AEOLBJFQhPCChCuEBCVUID0ioQnhAQhXCA8GX/VCpQP7txjPOlWr3a5k//9w+f7eTK6oQHpBQhfCAhCqEByRUITwgoQrhAQlVCA9IqEJ4QEIVwgMSqhAekFCF8ICEKoQHJFQhPCChCuEBCVUID0ioQnhAQhXCAxKqEB6QUIXwgIQqhAckVCE8IKEK4QEJVQgPSKhCeEBCFcIDEqoQHpBQhfCAhCqEByRUITwgoQrhAQlVCA9IqEJ4QEIVwgMSqhAekFCF8ICEKoQHJFQhPCChCuEBCVUID0ioQnhAQhXCAxKqEB6QUIXwgIQqhAckVCE8IKEK4QEJVQgPSKhCeEBCFcIDEqoQHpBQhfDAEw5VPcQ25jEcx+z82T2eeshji/tTGN2+7fvdc3z795O/AzPDo5xvRYBSNb587r/K/E3mXxE80msmY3oyHmWkj//gZprKjnEuvesnCnCAIgxmKcp1lApxrkDrJs5lBKZNUW6ilMG5AnAoVcPoBKUCyrKLo0JhCIIZFIbKjtmXvMiMW+CaO09hx9TMFJvjczhXYHSTKGhTVH2szQH29jEZlt7ZLqGq+jjKx3o+tGoAYN3wse730eye+y/SqoExdYryFlGwj5fC7/CL4j8oynVatWNUrmSYfQJUBGaastoALPVwgX7Vx+FQqJ3zNjmOUjWcy+44pqME54DqrhEYtK7vzEGDstrC6CbWjcFZlE523gsAFucqtKoRBm2MjqhsTlasUosOUtkM50rKqneP4+wuAp+PyegpWvEhtscfP/Z5fxhfa6hRsAhAaYdoFRAFbZyzZMUG1o0AUBjcbSdGEbDQ+AYOiyFkM79KEh2iHnTo5Z9RD+dp6A6p66Hjw1hX0tLzrKYfUZTrGJ1QVsO9k+koKcpb7L4xbqZnCZMYKkiLdcbFzTsWiqIaolVMxXhnQZhmoXaSOlPM2zmu6PNUFGgMm+lFjE6wrqAo19l942kVU9ltdq8IemcldhQ7v3OI1jXAYm2OdSlhMEsj3EduB4yyJxdqIz7KKF/BuYIwmNs5d59TO1dOrQM0ima0j2075nX9Jn2X8VFN008vEZiEytZoxUfYb56niMYEOibUdRSaGXWALdboji8RhnOk+TW0bgJgdI1GuI/t9NJdi7jF2TFBMEOgE6pqG6UCnC1QKgRncW7ytVIxRge04yWaukPNNdjiBl1niXQDZaYYF5s04iWSYJopFlivrlC5kkDH9LOVvUW5rLZQSmNUOFkMbH9vRFo1sC6lES8xzC5/bfOinLv36gmgVHD/H+4xfHFFAlDM1l9kXi1xy31CQ3c4Vj1NTQd8pM6zNv4FZdUFFPX4CJFusqROscLHfDt8g8VE8U/9D3nKHqWrN2m6KW6qzzhol9AoEkKOJDV+lJ9jPb/EOF/Zu+pO7uirvXFMvrfsXqVr0UGKsk9lB3dspzAY08I5uxPazm+o28wlJ/iWeYXYwHKackF/ROUKFjnKKpdQaAo7opde2DveoeZbjN02b6jTFM5xlTVGqo/DErmElAEj26WXXqVVO4JRIWm1zSj75I7zeKDxLYZ2g+3x2QfOhnPl3j3hw8zf5Iq2G4OinZygl17CuYJGfJRhdoXdK4vWLQLdYCZeIrU99ulj/EZymH/sv8NR8wpTrsmW6rFiPyIyTQwhbeb57dZhfr49YENvErvJojXn2vz58SHnttv88EbO+8X3mYmfpl+skZfbWJfddgYMgWmxv3aS5eG74Eocu1fcyQKsdQvnMmaTF+iml7C2jyJgKjlORx9hyk0Tu5Dnkxalg9I6PipuoHc+/Z2uLzAsHIVzvJP9gOngEH/YfJGlRsHffPZv1IMOCs2guEFWXN8b2VTtOMN8jSPJr3Nl+A5fvBtRzDVeYVxuPVTIt8/fHXv5KqEGZoaXo99jaueKMXAZb842+XQAM7FidWzZLnNe78Qs1gqSoKSbRbx3S9Gtcpo6ZNumrJo1fr/5DAeSEqUc3TygVyjO9TK0UsRKE2rN24sFF/oxVwYVy3aDPzvY5mYa8p/rQ7q6y4At1rOLkyuraZGEc2Rln6X4NMvFBzhnMToiL/tYm6JUQGAaVDYjNA0WouOkbsC46jLIr9OIFmmZRTbyyxyKXqZjOxyrNXljLufMVsy/j8/Tth3W1XW2yhWOmdNkKuXS6EdE4Qx/ve+7XBtrbqUVx1qGtIKz/ZTXZ2Omo4qFWsbZrTorI7AOjrXgSCPjYr9GurN+DEv4tU7GWhryt9e+d8cC8qCJftD8zTVe5a8WvsHN1LBVKC4NUy7pC7zgTnCqHVAzMKoUGxkkBj4blUyFhmdbjpm45HI/4i+/+TP+7n9O86enzvKvF59jNir4wfWYZqD5g0NdPhk0sUyWrsIpNGCU43BzyHf/6Pv89798h/fWFnh/o+K1jmEt1VwZ5pyeDQH45+4qFSXfbhwm0nB1ULFejempAUt6novuGiUlp/QSgVLM1xT/2x9xXp/hpP1V2kFEYhRToaIVOv74mSus9qdZHjS5MY5IK5irVZyc6fL+rQ7jUnF54HimpfjmwiY3x3WaYUGoLR9sttnMFAfqFdYpnm0Nma2NONud5fIg5HCjZHUcsDy0PDeldi4L0AotK0PD32/8A/a2q/GD5u+O1r70VQ9gdILDcbQREWrYykO+tW+dVjjLfJxjXUIxCjhcz1hIJre6eWWYCmO0iom0Is0DcjeicrCZG0LteHcjpdi5dV0Km5wpV1nOz/De9Wn2u6Msu/9jyiwyLGd5Y2GdtfECa2mdyh1gafZFPu6nlDj2RzVsBDeKlHF0nMwNOGZPUEaWVKWM1YjE1enrHs/aI1jrqJxlqHKacQxAZR2HgqdJbMh0EHErK7nYj7k2KnnVPEsSas6nISYMUVazyXW0rhHqhGGpSCvHzWpEJ29RM5M37HxcMl/LONTaZlCENMOAXqF5YbrPyX3XmVvfx7gMsE6xMposgrlVtOJDbI2/PNRHMc0ihVOcnuuxnUcoEj5NY441Ql6b39rb7kKvRaQtpQtpBjBXy3m61eOTwTyfrS1SMzAY10krjVKORqDYyEsOtLdoxRkXt2Z4bmaTc91ZZqOca6OEd29Oc/wnp7m4NYMFZsKAg/WUpxqOTpzwJyfO8cPLz/IXB2e5kUY4Z/npRoVRirqKaNHhuZZmOj1MO4IjjYJOnLOexgzLOucziJThcEMzLGExsRxtjuilda70ptjIAtZSRWKgVxj+a3WOs72K6dBQWEtaBayOGnzYrfE7T40wyjIVViRG8SvtHhbFCwdWmOl06awcJF8+wluHlrmwMc902OC3DlxnXIaMi5ALvRa5hUa0SD/98lDv57Hc+i40XuW4PckVfZEm06y7ZayrKOyY0o73PrgDaB0RmSkql1HZDK1C8nKTZnwIrUIausPa+EOioE2oE9rBQa4Pf47WNcpqA6UiAtPG2pz99ZexrqIkI7MDnKuomTalyyjt5HauYeboFp+SlztvcGeJwhkUmkDHZGV/74GRdQWV7ZNEBwhUTFb1Kcpt4rBDI5ynsGMausPIdsntgKIaUgumic0UhpBRtUE/vYjRbazLSKLFvc9kWdUjzSe3TMa0aEYHGeTXAE0z2o91BYmZIVFtAhewaPfx9kLEB5uKH5c/eeiHGI9+6xvxfP13eTnaz0/zq2y7NXI7oGkW9rZZzy5QVaOdz9gaheFA4zR11+JK+i4Hk1dZGb3PXHKCU+4lrqt1lsszvBm8zYYdc1V/zBH7HKtmhWLnNrvBDLkaExDTtzfZzpYJTMKB8BSbdgWjQrrjC8zWn2dQ3KAedEirbSqb45wFoKz6xGGHQMdoFaLQaGXYSq8AUAs7KAwn9Bts6g163ERjyO2IQMe85F7hkr7KwG5Q2NFkfsN5NIZx1WWfOc6n2c84Hv0my/YMlSsoq5TKjnfPL1PxU0zpRXp2be/vWDV5Tb/IW4sF53sx3+v9mK3xOe79EfH+83fHPH31UB+VQql48qEfhaOCvZsEd9eWwRc+i9y9r/s9oXy0bR5u3Pfbj1IRAM7l93iNRu08LPs8NIXRUw+8jb3XE9EHedRQ733Mu5/C32u7aOfJ+/rOA8EHLSKGz58T7O1ld9SPOsy79vEwr7/7WYpB751f7jP+yZiVisHtPpy819Poe5s8aBo95PgmfolCFV+nrxqqeLLuF6r8zyQhPCChCuEBCVUID0ioQnhAQhXCAxKqEB6QUIXwgIQqhAckVCE8IKEK4QEJVQgPSKhCeEBCFcIDEqoQHpBQhfCAhCqEByRUITwgoQrhAQlVCA9IqEJ4QEIVwgMSqhAekFCF8ICEKoQHJFQhPCChCuEBCVUID0ioQnhAQhXCAxKqEB6QUIXwgIQqhAckVCE8IKEK4QEJVQgPSKhCeEBCFcIDEqoQHpBQhfCAhCqEByRUITwgoQrhAQlVCA9IqEJ4QEIVwgMSqhAekFCF8ICEKoQHJFQhPKCcc096DEKIB5ArqhAekFCF8ICEKoQHJFQhPCChCuEBCVUID/w/DqqcLyC4Hy8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for gene in genes:\n", + " for orient in orients:\n", + " fig, axs = plt.subplots(1,2, figsize=(4, 2), **args)\n", + " for ax, (pheno, instance) in zip(axs, data.items()):\n", + " ax.axis(\"off\")\n", + " proj = common.Projector(instance[gene], box_size=400)\n", + " proj.set_projection_mode(ax=orient, mode=mode)\n", + " proj.set_vmin_vmax_gfp_values(0, vmax)\n", + " view = proj.project_on(alias=\"gfp\", ax=ax)\n", + " plt.savefig(f\"FigureEdges2_{gene}_gfp_{orient}.png\", dpi=150)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "8279f9c7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "complete 2023-04-27 09:10:06\n" + ] + } + ], + "source": [ + "common.now(\"complete\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45f830fe", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/FigureEdges/FigureEdges3-Decouple.ipynb b/notebooks/FigureEdges/FigureEdges3-Decouple.ipynb new file mode 100644 index 0000000..1398af7 --- /dev/null +++ b/notebooks/FigureEdges/FigureEdges3-Decouple.ipynb @@ -0,0 +1,1712 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "987615bd", + "metadata": {}, + "outputs": [], + "source": [ + "# Generate LDA histograms and reconstructions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "696163b2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Thu Apr 27 09:07:44 PDT 2023\r\n" + ] + } + ], + "source": [ + "!date" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c5cb5977", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/matheus.viana/anaconda3/envs/lab-variance/bin/python\r\n" + ] + } + ], + "source": [ + "!which python" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "89d80269", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cvapipe-analysis 0.1.0 /allen/aics/assay-dev/MicroscopyOtherData/Viana/projects/cvapipe_analysis\r\n" + ] + } + ], + "source": [ + "!pip list | grep cvapipe" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "26627787", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import importlib\n", + "import concurrent\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pathlib import Path\n", + "from tqdm.notebook import tqdm\n", + "from skimage import io as skio\n", + "import matplotlib.pyplot as plt\n", + "from aicscytoparam import cytoparam\n", + "from sklearn.decomposition import PCA\n", + "from aicsshparam import shtools, shparam\n", + "from aicsimageio import AICSImage\n", + "from aicsimageio.writers import OmeTiffWriter\n", + "from cvapipe_analysis.tools import io, viz, general, controller, shapespace, plotting\n", + "\n", + "sys.path.insert(1, '../tools')\n", + "import common" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "246fafb4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(147, 1218) /allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca9\n" + ] + } + ], + "source": [ + "# Controller form cvapipe_analysis\n", + "staging = Path(\"/allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca9\")\n", + "config = general.load_config_file(staging)\n", + "control = controller.Controller(config)\n", + "device = io.LocalStagingIO(control)\n", + "df = device.load_step_manifest(\"preprocessing\")\n", + "print(df.shape, control.get_staging())" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "81462cf1", + "metadata": {}, + "outputs": [], + "source": [ + "space = shapespace.ShapeSpace(control)\n", + "space.execute(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "bb13efd2", + "metadata": {}, + "outputs": [], + "source": [ + "# local_staging_variance_edges is generated by using the output dataframe from the\n", + "# mapping process to filter out not matched cells from the full dataset.\n", + "dsname = \"pca62\"\n", + "datasets = {\n", + " dsname: {\n", + " \"control\": \"/allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca9\",\n", + " \"perturbed\": \"/allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca62\"\n", + " }}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "88af31a9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tpca62 loaded. (138, 1218)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NUC_MEM_PC1DistSelfDistNNCellIdMatchpca62
datasetstructure_nameCellId
baseADH067j0pix0.014331NaNNaN-1FalseTrue
32asvegl0.130543NaNNaN-1FalseFalse
3gp9pks00.992096NaNNaN-1FalseFalse
466dclnw0.700845NaNNaN-1FalseFalse
4731xeaf0.327921NaNNaN-1FalseFalse
\n", + "
" + ], + "text/plain": [ + " NUC_MEM_PC1 Dist SelfDist NNCellId Match \\\n", + "dataset structure_name CellId \n", + "base ADH 067j0pix 0.014331 NaN NaN -1 False \n", + " 32asvegl 0.130543 NaN NaN -1 False \n", + " 3gp9pks0 0.992096 NaN NaN -1 False \n", + " 466dclnw 0.700845 NaN NaN -1 False \n", + " 4731xeaf 0.327921 NaN NaN -1 False \n", + "\n", + " pca62 \n", + "dataset structure_name CellId \n", + "base ADH 067j0pix True \n", + " 32asvegl False \n", + " 3gp9pks0 False \n", + " 466dclnw False \n", + " 4731xeaf False " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "smapper = shapespace.ShapeSpaceMapper(space, output_folder=\"./\")\n", + "smapper.use_full_base_dataset()\n", + "smapper.set_make_plots_off()\n", + "smapper.set_distance_threshold(1e10)\n", + "smapper.map(datasets)\n", + "df_map = smapper.result\n", + "df_map.head()" + ] + }, + { + "cell_type": "markdown", + "id": "fe7b4366", + "metadata": {}, + "source": [ + "### Loading and voxelizing matched shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "afbd348f", + "metadata": {}, + "outputs": [], + "source": [ + "nisos = control.get_number_of_interpolating_points()\n", + "inner_alias = control.get_inner_most_alias_to_parameterize()\n", + "fname = f\"avgshape/{dsname}_{inner_alias}_matched.vtk\"\n", + "inner_mesh = device.read_vtk_polydata(fname)\n", + "outer_alias = control.get_outer_most_alias_to_parameterize()\n", + "fname = f\"avgshape/{dsname}_{outer_alias}_matched.vtk\"\n", + "outer_mesh = device.read_vtk_polydata(fname)\n", + "domain, origin = cytoparam.voxelize_meshes([outer_mesh, inner_mesh])\n", + "coords_param, coeffs_centroid = cytoparam.parameterize_image_coordinates(\n", + " seg_mem=(domain>0).astype(np.uint8),\n", + " seg_nuc=(domain>1).astype(np.uint8),\n", + " lmax=control.get_lmax(), nisos=[nisos, nisos]\n", + ")\n", + "coeffs_mem, centroid_mem, coeffs_nuc, centroid_nuc = coeffs_centroid\n", + "coords_param += np.array(centroid_nuc).reshape(3, 1, 1)-np.array(centroid_mem).reshape(3, 1, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "0e5c56e0", + "metadata": {}, + "outputs": [], + "source": [ + "domain_nuc = (255*(domain>1)).astype(np.uint8)\n", + "domain_mem = (255*(domain>0)).astype(np.uint8)" + ] + }, + { + "cell_type": "markdown", + "id": "33e5ee15", + "metadata": {}, + "source": [ + "### Control and Device for each shape matched dataset (control and perturbed)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4ba10598", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(io)\n", + "importlib.reload(common)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "52c51980", + "metadata": {}, + "outputs": [], + "source": [ + "dsmanagers = common.setup_cvapipe_for_matched_dataset(datasets[dsname])" + ] + }, + { + "cell_type": "markdown", + "id": "f6614dea", + "metadata": {}, + "source": [ + "### Load representations and compute PCA" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "17b429ca", + "metadata": {}, + "outputs": [], + "source": [ + "gene = \"SARC\"\n", + "namemap = {\"control\": \"base\", \"perturbed\": dsname}" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "3aefde05", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/20 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PC1PC2PC3PC4PC5PC6PC7PC8PC9PC10...PC23PC24PC25PC26PC27PC28PC29PC30PC31PC32
DatasetCellId
0n5p262x9-0.457712-1.543619-0.3433910.950466-2.5385340.188054-0.135205-1.695079-0.549850-4.486278...0.444408-0.1181440.658282-0.569159-0.223836-0.0465960.1680400.0168290.1707100.441670
esd0qih80.5081530.2425390.3520000.202276-0.196177-0.099948-0.0596250.054081-0.0757350.115931...0.0750020.017799-0.2527050.1023350.0102070.1477590.200752-0.280328-0.3293540.106681
iid2uyz50.523737-1.003162-0.855465-0.616497-0.746364-0.255584-0.561897-1.447925-0.4182120.466586...1.870595-2.636516-2.252408-0.030804-0.0286710.274490-0.2639230.120489-0.0708850.085903
yjuw9t9d-0.4858201.223378-1.0559410.8238700.1433920.8842791.353711-0.6558062.665769-0.330736...-0.683367-0.8270011.149963-2.064859-0.085778-0.236089-0.3873980.1870240.0375590.224568
f56xrfp60.5061230.2425210.3456110.139688-0.212323-0.0944210.0156230.060021-0.0762320.165395...0.0977230.090161-0.2578240.087240-0.1338120.1648250.199655-0.149999-0.1658490.070061
\n", + "

5 rows × 32 columns

\n", + "" + ], + "text/plain": [ + " PC1 PC2 PC3 PC4 PC5 PC6 \\\n", + "Dataset CellId \n", + "0 n5p262x9 -0.457712 -1.543619 -0.343391 0.950466 -2.538534 0.188054 \n", + " esd0qih8 0.508153 0.242539 0.352000 0.202276 -0.196177 -0.099948 \n", + " iid2uyz5 0.523737 -1.003162 -0.855465 -0.616497 -0.746364 -0.255584 \n", + " yjuw9t9d -0.485820 1.223378 -1.055941 0.823870 0.143392 0.884279 \n", + " f56xrfp6 0.506123 0.242521 0.345611 0.139688 -0.212323 -0.094421 \n", + "\n", + " PC7 PC8 PC9 PC10 ... PC23 \\\n", + "Dataset CellId ... \n", + "0 n5p262x9 -0.135205 -1.695079 -0.549850 -4.486278 ... 0.444408 \n", + " esd0qih8 -0.059625 0.054081 -0.075735 0.115931 ... 0.075002 \n", + " iid2uyz5 -0.561897 -1.447925 -0.418212 0.466586 ... 1.870595 \n", + " yjuw9t9d 1.353711 -0.655806 2.665769 -0.330736 ... -0.683367 \n", + " f56xrfp6 0.015623 0.060021 -0.076232 0.165395 ... 0.097723 \n", + "\n", + " PC24 PC25 PC26 PC27 PC28 PC29 \\\n", + "Dataset CellId \n", + "0 n5p262x9 -0.118144 0.658282 -0.569159 -0.223836 -0.046596 0.168040 \n", + " esd0qih8 0.017799 -0.252705 0.102335 0.010207 0.147759 0.200752 \n", + " iid2uyz5 -2.636516 -2.252408 -0.030804 -0.028671 0.274490 -0.263923 \n", + " yjuw9t9d -0.827001 1.149963 -2.064859 -0.085778 -0.236089 -0.387398 \n", + " f56xrfp6 0.090161 -0.257824 0.087240 -0.133812 0.164825 0.199655 \n", + "\n", + " PC30 PC31 PC32 \n", + "Dataset CellId \n", + "0 n5p262x9 0.016829 0.170710 0.441670 \n", + " esd0qih8 -0.280328 -0.329354 0.106681 \n", + " iid2uyz5 0.120489 -0.070885 0.085903 \n", + " yjuw9t9d 0.187024 0.037559 0.224568 \n", + " f56xrfp6 -0.149999 -0.165849 0.070061 \n", + "\n", + "[5 rows x 32 columns]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "groups = np.array([0]*len(CellIds_ct) + [1]*len(CellIds_pt))\n", + "stds = axes.std(axis=0)\n", + "axes /= stds\n", + "axes, pca = common.sort_pcs(axes, groups, pca)\n", + "axes[\"Dataset\"] = groups\n", + "axes[\"CellId\"] = CellIds_ct.tolist() + CellIds_pt.tolist()\n", + "axes = axes.set_index([\"Dataset\", \"CellId\"])\n", + "axes.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "1a671ec5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,1)\n", + "for ds, df_ds in axes.groupby(\"Dataset\"):\n", + " ax.scatter(df_ds.PC1, df_ds.PC2, s=10, label=f\"{ds}: N={len(df_ds)}\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "78308d56", + "metadata": {}, + "source": [ + "### Compute LDA" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "163ec1a7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(common)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "2b92a1ee", + "metadata": {}, + "outputs": [], + "source": [ + "lda = common.SimpleBinaryLDA()\n", + "lda = lda.sfit(axes.values, groups)\n", + "lda_values = lda.transform(axes.values).flatten()\n", + "axes[\"LDA\"] = lda_values" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "6a68918d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 -1.1606076\n", + "1 0.504612\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "xmin, xmax = -3, 3\n", + "edges = np.linspace(xmin, xmax, 1+int((xmax-xmin)/0.5))\n", + "fig, ax = plt.subplots(1,1, figsize=(4.0, 2))\n", + "for color, (g, df_group) in zip([\"black\",\"#FF3264\"], axes.groupby(\"Dataset\")):\n", + " lw = 3 if g == 0 else 1.5\n", + " ax.hist(df_group.LDA, bins=edges, histtype=\"step\", color=color, density=True, lw=lw)\n", + " ax.axvline(x=df_group.LDA.mean(), color=color, lw=2, linestyle=\"--\", zorder=1e10)\n", + " print(g, df_group.LDA.mean())\n", + "ax.set_xlim(xmin, xmax)\n", + "for pos in [\"top\", \"right\", \"left\"]:\n", + " ax.spines[pos].set_visible(False)\n", + "ax.axes.get_yaxis().set_visible(False)\n", + "sigmas = np.linspace(-2, 2, 5)\n", + "ax.set_xticks(sigmas, [f\"{int(s)}$\\sigma$\" for s in sigmas])\n", + "ax.tick_params(axis=\"x\", which='major', labelsize=12)\n", + "plt.tight_layout()\n", + "plt.savefig(f\"FigureEdges3_{gene}_lda_hist.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "48b7efc7", + "metadata": {}, + "outputs": [], + "source": [ + "mps = [-2,-1.5,-1,0.5,0,0.5,1,1.5,2]\n", + "pcs_back = lda.walk(mps)#, limit_to_range=lda_values, return_map_points=True)\n", + "pcs_back *= stds.values\n", + "pcs_back = pd.DataFrame(pcs_back, columns=[f\"PC{i}\" for i in range(1,1+npcs)])\n", + "reps_back = pca.inverse_transform(pcs_back).reshape(len(mps), 65, -1)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "fc94cab1", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "269739c7b91946a08b3b14af99fc9b0f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/9 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mode = {\n", + " \"nuc\": \"center_nuc\",\n", + " \"mem\": \"center_nuc\",\n", + " \"gfp\": \"center_nuc\"\n", + "}\n", + "args = {\"gridspec_kw\": {\"hspace\": 0, \"wspace\": -0.3}, \"sharex\": True, \"sharey\": True}\n", + "for alias in [\"nuc\", \"mem\"]:\n", + " for orient in [\"z\", \"y\"]:\n", + " fig, axs = plt.subplots(1,len(mps), figsize=(2*len(mps), 2), **args)\n", + " for ax, instance in zip(axs, instances):\n", + " ax.axis(\"off\")\n", + " proj = common.Projector(instance, box_size=400)\n", + " proj.set_projection_mode(ax=orient, mode=mode)\n", + " view = proj.project_on(alias=alias, ax=ax, scale_bar={\"pixel_size\":0.18, \"length\":15})\n", + " plt.savefig(f\"FigureEdges3_{gene}_lda_{alias}_{orient}.png\", dpi=150)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "bf00da61", + "metadata": {}, + "outputs": [], + "source": [ + "# Percentil relative to center\n", + "contrast = common.Projector.get_shared_morphed_max_based_on_pct_for_zy_views(\n", + " instances = instances,\n", + " pct = 90,\n", + " mode = mode,\n", + " func = np.mean\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "5adbb59f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SARC 0 0.22920627726448906\n" + ] + } + ], + "source": [ + "orients = [\"z\", \"y\"]\n", + "vmin, vmax = 0, np.nanmax([contrast[ax][1] for ax in orients])\n", + "print(gene, vmin, vmax)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "43c5b83f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "args = {\"gridspec_kw\": {\"hspace\": 0, \"wspace\": -0.3}, \"sharex\": True, \"sharey\": True}\n", + "for orient in [\"z\", \"y\"]:\n", + " fig, axs = plt.subplots(1,len(mps), figsize=(2*len(mps), 2), **args)\n", + " for ax, instance in zip(axs, instances):\n", + " ax.axis(\"off\")\n", + " proj = common.Projector(instance, box_size=400)\n", + " proj.set_gfp_colormap(\"inferno\")\n", + " proj.set_vmin_vmax_gfp_values(vmin, vmax)\n", + " proj.set_projection_mode(ax=orient, mode=mode)\n", + " view = proj.project_on(alias=\"gfp\", ax=ax)\n", + " plt.savefig(f\"FigureEdges3_{gene}_lda_gfp_{orient}.png\", dpi=150)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c96fa364", + "metadata": {}, + "source": [ + "# Paused here" + ] + }, + { + "cell_type": "markdown", + "id": "b09f9be0", + "metadata": {}, + "source": [ + "### Reconstruct chosen instances along LDA" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a88e1d3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "6cc71310", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "control (147, 1218)\n", + "perturbed (138, 1218)\n" + ] + } + ], + "source": [ + "dfs = {}\n", + "for condition, manager in dsmanagers.items():\n", + " dfs[condition] = manager[\"device\"].load_step_manifest(\"preprocessing\")\n", + " print(condition, dfs[condition].shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "7ab59b4c", + "metadata": {}, + "outputs": [], + "source": [ + "# Ids from the gene being analyzed\n", + "representative_ids = {\n", + " \"TOMM20\": [350008, 324609, 321239, 973641, 267287, 929060],\n", + " \"ACTN\": [572411, 541232, 577227,560334, 635240, 556067]\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "5b5a5438", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2f7b6e9d7aba47fc9236d008b2b5e3d0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/6 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mode = {\n", + " \"nuc\": \"max\",\n", + " \"mem\": \"max\",\n", + " \"gfp\": \"mean\"\n", + "}\n", + "args = {\"gridspec_kw\": {\"hspace\": 0, \"wspace\": -0.1}, \"sharex\": True, \"sharey\": True}\n", + "for alias in [\"mem\", \"nuc\"]:\n", + " for orient in [\"z\", \"y\"]:\n", + " fig, axs = plt.subplots(1,len(instances), figsize=(2*len(instances), 2), **args)\n", + " for ax, instance in zip(axs, instances):\n", + " ax.axis(\"off\")\n", + " proj = common.Projector(instance, box_size=396)\n", + " proj.set_projection_mode(ax=orient, mode=mode)\n", + " view = proj.project_on(alias=alias, ax=ax, scale_bar={\"pixel_size\":0.108, \"length\":5})\n", + " plt.savefig(f\"FigureEdges3_{gene}_inst_{alias}_{orient}.png\", dpi=150)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "4b9f642c", + "metadata": {}, + "outputs": [], + "source": [ + "vmin, vmax = control.get_optimal_seg_contrast(gene)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "e25ad448", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for orient in [\"z\", \"y\"]:\n", + " fig, axs = plt.subplots(1,len(instances), figsize=(2*len(instances), 2), **args)\n", + " for ax, instance in zip(axs, instances):\n", + " ax.axis(\"off\")\n", + " proj = common.Projector(instance, box_size=396)\n", + " proj.set_projection_mode(ax=orient, mode=mode)\n", + " proj.set_vmin_vmax_gfp_values(vmin, vmax)\n", + " proj.set_gfp_colormap(\"binary\")\n", + " view = proj.project_on(alias=\"gfp\", ax=ax)\n", + " plt.savefig(f\"FigureEdges3_{gene}_inst_gfp_{orient}.png\", dpi=150)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "403c2543", + "metadata": {}, + "source": [ + "### Reconstruct morphed version of chosen instances along LDA" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "60d178c6", + "metadata": {}, + "outputs": [], + "source": [ + "nisos = control.get_number_of_interpolating_points()\n", + "inner_alias = control.get_inner_most_alias_to_parameterize()\n", + "fname = f\"avgshape/{dsname}_{inner_alias}_matched.vtk\"\n", + "inner_mesh = device.read_vtk_polydata(fname)\n", + "outer_alias = control.get_outer_most_alias_to_parameterize()\n", + "fname = f\"avgshape/{dsname}_{outer_alias}_matched.vtk\"\n", + "outer_mesh = device.read_vtk_polydata(fname)\n", + "domain, origin = cytoparam.voxelize_meshes([outer_mesh, inner_mesh])\n", + "coords_param, coeffs_centroid = cytoparam.parameterize_image_coordinates(\n", + " seg_mem=(domain>0).astype(np.uint8),\n", + " seg_nuc=(domain>1).astype(np.uint8),\n", + " lmax=control.get_lmax(), nisos=[nisos, nisos]\n", + ")\n", + "coeffs_mem, centroid_mem, coeffs_nuc, centroid_nuc = coeffs_centroid\n", + "coords_param += np.array(centroid_nuc).reshape(3, 1, 1)-np.array(centroid_mem).reshape(3, 1, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "86e9e4c3", + "metadata": {}, + "outputs": [], + "source": [ + "domain_nuc = (255*(domain>1)).astype(np.uint8)\n", + "domain_mem = (255*(domain>0)).astype(np.uint8)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "3dd65da4", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "707bafc32e5142ce854f3fa917a0e060", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/6 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAp4AAAB7CAYAAADdYICLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAI6UlEQVR4nO3cv2td5R8H8M9J+lPFWpNBtINCNKBVUEQziOAgTkI3F/8BB3F2ctNJpbo6iWOHitJBURy0iIKi1VahKdhSWoWa+CPVJDd5vkP9Vq03baL3fM550tcLHij3ktxT3nnD+56E25RSAgAA2jbW9QUAAHB1MDwBAEhheAIAkMLwBAAgheEJAEAKwxMAgBRbLvdk0zQ+a6kypZRGbtA+XYMculanUkoz7HF3PAEASGF4AgCQwvAEACCF4QkAQArDEwCAFIYnAAApDE8AAFIYngAApDA8AQBIYXgCAJDC8AQAIIXhCQBACsMTAIAUhicAACkMTwAAUhieAACkMDwBAEhheAIAkMLwBAAgheEJAEAKwxMAgBSGJwAAKQxPAABSGJ4AAKQwPAEASGF4AgCQwvAEACCF4QkAQArDEwCAFIYnAAApDE8AAFIYngAApDA8AQBIYXgCAJDC8AQAIIXhCQBACsMTAIAUhicAACkMTwAAUhieAACkMDwBAEixpesLuJKxsbFommbN51dXV6OUknhFrIfc6iOzOsmtPjKrk9xGozfDc8eOHXHTTTfFnj174t57742JiYmIiLjnnnticnJyza/74osv4ty5cxER8euvv8ann34aKysrMTc3F6dPn46IiPPnz8fS0lL7/4mrkNzqI7M6ya0+MquT3NrVXG6dN03T6nTftm1bzMzMxL59+2JmZibuuOOOuOGGG2J8fPxff8+VlZWIuBDu/Px8RETMzs7GmTNn4vDhw7G4uBgnT56M48ePx6lTpzbdD0AppZEbl5LZ6Okaw8hs9HStTqWUobeHOxued955Z7zwwgvx6KOPxs6dO9t6maEGg0EsLCzE559/Hh9++GF88sknceTIkTh16tTFH5RatV1QudVHZu3QNS4ls3boWp16NTynp6fjwIEDsXfv3ja+/YaVUuLcuXPx8ccfx/vvvx+HDx+Ob775Jn766aeuL23D2iyo3Oojs/boWp25tUVm7dG1enNb64k1T0SUUZ/x8fHy+uuvlz5bXFwsR48eLS+//HJ55JFHyq5du8ofP/S9P0VuVeYms/oyK7pWZW4yqy+zomvV5jbspN/xnJiYiC+//DJuvvnmUX/rViwvL8fs7Gy88847cfDgwfjss896/c6jtPTOUG71kVm7dO2C2nJrg8zapWsX1JjbsMcNzw1YWlqK2dnZOHToULzxxhvx9ddfx/LycteX9TcK+k815NYGmbVL1/6phtzaILN26do/1ZLbWk+k/6r9rbfeyrtP3ZJffvmlHDhwoDz00ENly5Ytnd/S/v8pcrusvuYms7X1NbOia5fV19xktra+ZlZ07bL6nNuwkz48I6Ls27evLC0tdZHPyC0sLJRXXnmlTE1N9eLvLorc1qVvucnsyvqWWdG1delbbjK7sr5lVnRtXfqY27DTyfC85pprygcffNBFLq35/vvvy0svvVRuueWWzoOW2/r1JTeZrV9fMiu6tiF9yU1m69eXzIqubUifcht2OhmeEVFmZmbK2bNnu8ikVceOHStPP/10mZyc3HQFlVudR2a61idd5yazjes6s6Jr/0ofcht2OhueTdOUZ555pgwGgy7yaNXq6mo5duxYeeKJJ8rOnTs3VUHlVt+Rma71ja7VR9fq1HVuw05nwzMiyrXXXlsOHTrURRYpFhcXy5tvvlnuuuuutL+3KHL7z7rITWb/ja7VSdfqo2t16iq3YafT4RkRZWpqqpw4caKLHNKcPn26PPXUUynvNorcRiYzN5mNhq7VSdfqo2t1ys5t2Ol8eEZEefLJJ8vi4mIXGaQZDAZl//79rYdd5DZSWbnJbHR0rU66Vh9dq1NmbsNOL4bn1q1by/79+8vq6moXGaQZDAblxRdfbPVztorcRi4jN5mNlq7VSdfqo2t1yspt2OnF8IyIMjExUQ4ePLjpw/7555/Lgw8+uCkKKrc6j8x0rc90rT66VqeM3Iad3gzPiCi7d+8uzz//fDl//nwXGaR57bXXNk1B5VbnkZmu9Zmu1UfX6tR2bsPOWPTI3NxcPPfcc/H444/H22+/Hb/99lvXl9SKH374oetLGCm51UdmdZJbfWRWJ7m1aK1FWjp4h/HXs23btvLAAw+UV199tRw/frwsLy938WZg5I4cOVKmp6c31TtDudV9ZKZrfaJr9dG1OmXkNuw05UKgQ/3xWU+dapombrzxxrjvvvvi4Ycfjsceeyympqbiuuuui61bt3Z9eetSSokff/wxPvroo3j22Wfj6NGjbb5WI7fRyMytD2S24dfStRHRNZld4bV0bUSycxv2eO+H56W2b98ee/bsidtuuy1uv/32uPXWW2N6ejrGx8dj7969sWPHjpicnIyxsT//iuCv//6vyp93g4ean5+P33//PSIiTpw4EWfOnIl333033nvvvTh58mQMBoORXcsa19eLgl5KbvWR2RWvT9eG6HtufSSzK16frg1RQ27DHq9ueK6laZrYtWtXbN++/WLwERHXX3993H///RfDbpom7r777vj2229jcXHx4tfv3r075ubmrvg6X331VZw9e3bN57/77ruYn5+PiIiFhYW/vUaGvhZ0LXKrj8wu0LXh+p5bTWR2ga4NV0Nuwx7fNMNzI8bHx2NlZeVvjzVNc9l3DrWoraAbsZlz26w2c2a6Rp9s5sx0rU6G51ViMxcU+kTXIIeu1Wmt4dmrj1MCAGDzMjwBAEhheAIAkMLwBAAgheEJAEAKwxMAgBSGJwAAKQxPAABSGJ4AAKQwPAEASGF4AgCQwvAEACCF4QkAQArDEwCAFIYnAAApDE8AAFIYngAApDA8AQBIYXgCAJDC8AQAIIXhCQBACsMTAIAUhicAACkMTwAAUhieAACkMDwBAEhheAIAkMLwBAAgheEJAEAKwxMAgBSGJwAAKQxPAABSGJ4AAKQwPAEASGF4AgCQwvAEACCF4QkAQArDEwCAFIYnAAApDE8AAFIYngAApGhKKV1fAwAAVwF3PAEASGF4AgCQwvAEACCF4QkAQArDEwCAFIYnAAAp/ge4H2UuMhebIgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for alias in [\"mem\", \"nuc\"]:\n", + " for orient in [\"z\", \"y\"]:\n", + " fig, axs = plt.subplots(1,len(instances), figsize=(2*len(instances), 2), **args)\n", + " for ax, instance in zip(axs, instances):\n", + " ax.axis(\"off\")\n", + " proj = common.Projector(instance, box_size=396)\n", + " proj.set_projection_mode(ax=orient, mode=mode)\n", + " view = proj.project_on(alias=alias, ax=ax, scale_bar={\"pixel_size\":0.108, \"length\":5})\n", + " plt.savefig(f\"FigureEdges3_{gene}_morphinst_{alias}_{orient}.png\", dpi=150)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "088f6a99", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for orient in [\"z\", \"y\"]:\n", + " fig, axs = plt.subplots(1,len(instances), figsize=(2*len(instances), 2), **args)\n", + " for ax, instance in zip(axs, instances):\n", + " ax.axis(\"off\")\n", + " proj = common.Projector(instance, box_size=396)\n", + " proj.set_projection_mode(ax=orient, mode=mode)\n", + " proj.set_vmin_vmax_gfp_values(vmin, vmax)\n", + " proj.set_gfp_colormap(\"binary\")\n", + " view = proj.project_on(alias=\"gfp\", ax=ax)\n", + " plt.savefig(f\"FigureEdges3_{gene}_morphinst_gfp_{orient}.png\", dpi=150)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "ad52b276", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "complete 2022-06-27 13:15:31\n" + ] + } + ], + "source": [ + "common.now(\"complete\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4157f7c5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/MovieEdges/MovieEdgesLDA-Decouple.ipynb b/notebooks/MovieEdges/MovieEdgesLDA-Decouple.ipynb new file mode 100644 index 0000000..27f8b2f --- /dev/null +++ b/notebooks/MovieEdges/MovieEdgesLDA-Decouple.ipynb @@ -0,0 +1,1264 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "987615bd", + "metadata": {}, + "outputs": [], + "source": [ + "# Generate LDA histograms and reconstructions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "696163b2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Thu Apr 27 10:18:44 PDT 2023\r\n" + ] + } + ], + "source": [ + "!date" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "be5090b7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/matheus.viana/anaconda3/envs/lab-variance/bin/python\r\n" + ] + } + ], + "source": [ + "!which python" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "52ddf16e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cvapipe-analysis 0.1.0 /allen/aics/assay-dev/MicroscopyOtherData/Viana/projects/cvapipe_analysis\r\n" + ] + } + ], + "source": [ + "!pip list | grep cvapipe" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "26627787", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import pickle\n", + "import importlib\n", + "import concurrent\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pathlib import Path\n", + "from tqdm.notebook import tqdm\n", + "from skimage import io as skio\n", + "import matplotlib.pyplot as plt\n", + "from aicscytoparam import cytoparam\n", + "from sklearn.decomposition import PCA\n", + "from aicsshparam import shtools, shparam\n", + "from aicsimageio import AICSImage\n", + "from aicsimageio.writers import OmeTiffWriter\n", + "from cvapipe_analysis.tools import io, viz, general, controller, shapespace, plotting\n", + "\n", + "sys.path.insert(1, '../tools')\n", + "import common" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "246fafb4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(147, 1218) /allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca9\n" + ] + } + ], + "source": [ + "# Controller form cvapipe_analysis\n", + "staging = Path(\"/allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca9\")\n", + "config = general.load_config_file(staging)\n", + "control = controller.Controller(config)\n", + "device = io.LocalStagingIO(control)\n", + "df = device.load_step_manifest(\"preprocessing\")\n", + "print(df.shape, control.get_staging())" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "81462cf1", + "metadata": {}, + "outputs": [], + "source": [ + "space = shapespace.ShapeSpace(control)\n", + "space.execute(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bb13efd2", + "metadata": {}, + "outputs": [], + "source": [ + "# local_staging_variance_edges is generated by using the output dataframe from the\n", + "# mapping process to filter out not matched cells from the full dataset.\n", + "dsname = \"pca62\"\n", + "datasets = {\n", + " dsname: {\n", + " \"control\": \"/allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca9\",\n", + " \"perturbed\": \"/allen/aics/assay-dev/MicroscopyOtherData/Viana/datasets/AbbyCardios/staging_pca62\"\n", + " }}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "88af31a9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tpca62 loaded. (138, 1218)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NUC_MEM_PC1DistSelfDistNNCellIdMatchpca62
datasetstructure_nameCellId
baseADH067j0pix0.014331NaNNaN-1FalseTrue
32asvegl0.130543NaNNaN-1FalseFalse
3gp9pks00.992096NaNNaN-1FalseFalse
466dclnw0.700845NaNNaN-1FalseFalse
4731xeaf0.327921NaNNaN-1FalseFalse
\n", + "
" + ], + "text/plain": [ + " NUC_MEM_PC1 Dist SelfDist NNCellId Match \\\n", + "dataset structure_name CellId \n", + "base ADH 067j0pix 0.014331 NaN NaN -1 False \n", + " 32asvegl 0.130543 NaN NaN -1 False \n", + " 3gp9pks0 0.992096 NaN NaN -1 False \n", + " 466dclnw 0.700845 NaN NaN -1 False \n", + " 4731xeaf 0.327921 NaN NaN -1 False \n", + "\n", + " pca62 \n", + "dataset structure_name CellId \n", + "base ADH 067j0pix True \n", + " 32asvegl False \n", + " 3gp9pks0 False \n", + " 466dclnw False \n", + " 4731xeaf False " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "smapper = shapespace.ShapeSpaceMapper(space, output_folder=\"./\")\n", + "smapper.use_full_base_dataset()\n", + "smapper.set_make_plots_off()\n", + "smapper.set_distance_threshold(1e10)\n", + "smapper.map(datasets)\n", + "df_map = smapper.result\n", + "df_map.head()" + ] + }, + { + "cell_type": "markdown", + "id": "25a4fb1c", + "metadata": {}, + "source": [ + "### Control and Device for each shape matched dataset (control and perturbed)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "076f0044", + "metadata": {}, + "outputs": [], + "source": [ + "dsmanagers = common.setup_cvapipe_for_matched_dataset(datasets[dsname])" + ] + }, + { + "cell_type": "markdown", + "id": "8ffe15ef", + "metadata": {}, + "source": [ + "### Load representations and compute PCA and compute LDA" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "29455865", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running dataset: pca62\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/20 [00:000).astype(np.uint8),\n", + " seg_nuc=(domain>1).astype(np.uint8),\n", + " lmax=control.get_lmax(), nisos=[nisos, nisos]\n", + ")\n", + "coeffs_mem, centroid_mem, coeffs_nuc, centroid_nuc = coeffs_centroid\n", + "coords_param += np.array(centroid_nuc).reshape(3, 1, 1)-np.array(centroid_mem).reshape(3, 1, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0e5c56e0", + "metadata": {}, + "outputs": [], + "source": [ + "domain_nuc = (255*(domain>1)).astype(np.uint8)\n", + "domain_mem = (255*(domain>0)).astype(np.uint8)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4f37d86a", + "metadata": {}, + "outputs": [], + "source": [ + "mps = [-2,-1.5,-1,-0.5,0,0.5,1,1.5,2]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "48b7efc7", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b44408aa71ae4fc8aa0c19520b8bfb16", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/3 [00:00" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importlib.reload(common)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "9c034c8c", + "metadata": {}, + "outputs": [], + "source": [ + "bbox = 400\n", + "(yyi, yyf, yzi, yzf), bbox, figargs = common.contact_sheet_params(box_size=bbox, ylow=110, zlow=70)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "0cf6d89f", + "metadata": {}, + "outputs": [], + "source": [ + "scale=2\n", + "ng = len(control.get_gene_names())\n", + "mode = {\n", + " \"nuc\": \"center_nuc\",\n", + " \"mem\": \"center_nuc\",\n", + " \"gfp\": \"center_nuc\"\n", + "}\n", + "args = {\"gridspec_kw\": {\"hspace\": 0, \"wspace\": 0}, \"sharex\": \"col\"}" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "ef8e05fc", + "metadata": {}, + "outputs": [], + "source": [ + "# Percentil relative to center\n", + "contrast = {}\n", + "orients = [\"z\", \"y\"]\n", + "for gene in control.get_gene_names():\n", + " contrast_gene = common.Projector.get_shared_morphed_max_based_on_pct_for_zy_views(\n", + " instances = data[gene],\n", + " pct = 90,\n", + " mode = mode,\n", + " func = np.mean\n", + " )\n", + " vmin, vmax = 0, np.nanmax([contrast_gene[ax][1] for ax in orients])\n", + " contrast[gene] = vmax" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "fc94cab1", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOkAAAFzCAYAAADbvS5yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACAI0lEQVR4nOzdd3xW5f3/8dcZ9x7ZeycQEjZJ2EMciAvc1lVtrauu2qodVqu2dlhra/VbW7GOWvcWcaPsTRgBAiQhe+/ce5zx+wO1rT+rIiEJ9DzzyEPkvu/zuXIO71xnXOc6gq7rGAyGkUsc7gYYDIYvZ4TUYBjhjJAaDCOcEVKDYYQzQmowjHBGSA2GEU7+shcFQTauz4xguq4Iw90Gw5H3pSE1HF3MZrNuMpkOezmKoiDLg/NPYyQuayS2KRAIRHVdN3/hi7qu/9dvkHTje+R+f357lZaW6oNhsJYzUpc1EtsEbNX/Sw6NY1KDYYQzQmowjHBGSA3/n6uvvvqYXtZIbNOXEfQvGWBvnN0d2T5/dresrEzfunXrcDXHcBgEQSjXdb3si14zelKDYYQzQmowjHBGSA2GEc4IqcEwwhkhNRhGOCOkBsMIZ4TUMOiG4trhf3Xv08NX+wgxQmoYdI899tjwFX99zfDVPkKMkBoMI5wRUoNhhDtG7ycVEAQTuh4FdODT0XOf/52kDm2z/ke0tLQMX/H37h++2kfIURRSARDJJxcXLo7jOEREkkgkioqAhAM7PryAiKAL6ETR0QABETMIIpJoQVG9xBLLeMaylvXYsdJGOweoo1HsZqe2/pPPGb6J8vJy0tPTh6f43gZIih2e2kfIiBxgb8FCLvnMZR6JUiYJQiKiEiYgKrTrLbTrbZSLu/Dgxa/7QLYiCCJm0YFbTqMnUotdTsAX7UASzdikOBKETJK0RPoFD/XqDsJKP4IgoqoBBF3AgYnJTKbQVEJuNAkrFhTC1FNPNbXsoYJ22odjdfxXI3WAvSAIfNm/qyOq9CooH8YTV9/Qlw2wH+aeVMCGg1xhDPP06eQI+Zh1nRAh9rKfNazGq+t0C/0gg0V2IQomvKEGQCTRVkw+GagoKCj0ak3YdRdTzKeh6joJLpmAoiMKkOsEkwDZDoFG/0KqvWCXBD4MVxDSPTjEBGr0KLv15fjpQhRk1KiXZCGVyfpYLtYvIZlEVHS66WY3u9jMZgbwcHCX2mA4MoY8pAIyUywLOF1fQJ6Wi4DIfrGOlyN/pd2kEtX8uC0ZiEh4ol5iTJkUUEyqlsAesQKzYOe7qccjCTq7+hVCuopFkJiWIJFkySSgilhEjcmJndgtYV47kMei3Ea6/U5CikyGewBJSGRsrILLFEFumoiiwSi3So1HoiroI2iKIOoCiqzi1h30ofOuWEuj8gY6Kml6CqOjqdwi/gI3TsJ6kK3aWlawim66hnqVGo5xQxRSgQQhk8u5mAnydJLtIR4JbuSvpmc53TKDmmCALqtAtjSRE5zpRDWo9oXJc0+lwKkQa1ZItAbZN1BCZ0ji28X72dqaRX/EjkM2MSE2QGF8G+MmVFKzdzSBiIVg1MTYov3c9biOmjQR+6rHCa4xY0ntYfLVt2Jf8zjhdQry+8ej6iJOc5gF2WFeO5BPkVvAq8iYBJ32kJkUa4TN3ekEBC923YVbc7HP3MEW7RmcYgJWzUZs0MsV+hUkkYCKxgY28R7vECY8NKt4BHn00UeHr/jPvz18tY+QI3pMKiBzsngmZ4lnEhAiPKz8EdWRyqm2Yt4J7sGrdlJIKRMdbuItOqoG107dxjM7ptDoF/lR2W5aexPpCjjQALOosa3XzaXjKtnRks2pMzegqRJaVMKZ1o39vt+j/OEa+s86mY3dFrbO+Bl+ZBwbXyPS5+LDaXM5TdlOTMpk5tLJVHrRn7mSyNS5yP2diJ1tBNeYWb1iDiFFZt7UrbTUZ6OqIr8tH83UBJWPOnSK3CaqvQo72Y2DWC6Iy+GFvjpaIjuJKL2gRziJUzmOWTiFOPaJNawRN1OpbEbXI4ezSv/DSD0mNRy6LzsmPWIhXSCcwZXS9SyXVlMuNBCUgjSru8kTS5jhSCSswnEpfuaNqaSrN4GszBYiYTOqIjHgcZOQ0EtHZxKVXal0hiyENYFZqR1U98WzuGwL9vgB7JmdvPLMeUzJqid9VAO1f36Yp8nHXPkOc97fTs5H7RRO38YvH7uUJr/AxLgokxJ6CKXbWVYwE+tpAqY4H1OLUzhv6bWo5/4BfvcTdE3g46UL0XSBcbl1ZB23naVPnM+cku1srZhAnSeGWHOEJ2rN2CWZFKtEokVnd7+KJAjYJZH3IivxhVtIs0/hdHUeJ5iKIBDHB+qbfCBvoClaweEey47UkBonjg7dkIY0R5rAbdzMNnbwT/1ZJltOZ0GCi8oBnR16LQVaNu899wqVj0xCEjVGnbAZ34EMBrri+XDPBMrSmxh30npEW4Rtb5xETU8S53/7ZcKdcYQ9DmxJ/VhOsCGe+Cu8P7iTml1F9JrdrH1wCqZR0/lB40Osv9BEf9iGVVZIdnr42548OkJRYkwyk+NUesISrUEIqTozklSSrzWzYdYk7pnlIkHzIIkW/F1rsf7zHyiLjsMy+lKCzW8jRAIo/7cdx7Qe/JsSaavJIS65hxVby9jUHYOqw03Tt/LB3vG83ARZNitnZvWi6iJ7+t1U9IIzGs+Njmns9wj8XXqaNeE30FEOdTUDRki/kBHSL3eiuJgLxAv5telhYoRMmvS9nGU/jl8tWMv2qjGc8r1X8e7JwtsdR1V9HhPHVbJ550SqB2IxixqTkttJS+yitSuZqQtXER1wsnNTCWmJXWS+cjn8/jYkZ5hAbSqW72SgWR3sG/MDHmM0t1CJ+8qf01yfRV1PEtt7Y8l1hFjabGGrvovjzZNwyAI7fB4mONy4TVA5EOWUdJ2TR+1HyRJ4/NZzOXP0aObT+R8/V3TX3xBCfiKvdCA7QvhbktBUibgpNdR9MJ2s0j1UrppGIGJhbWsGU5M7WdmaymhXgOl5NWyuL2B5mwuHDF0hndMzAmzujGNOeBoZajLX8Rv2Bj/mUHtWI6Rf4BgM6aCdOLpJuBVRtPED8cdM4gSuzJZItI0nM6aajZXjyI3vRhiVindVHG/vKMFtivK3j+dz/tg9uCwh2n1uxk/ZhdntI9NWiZwRBF3AYQmRUbIXvepFTKkhlHYrzj/9GoDynv0sJZs/Uo7puStZsft0Jo6rpH0gFrdJZWO3nQr2oxJld7iHjkgDUSFIOFBESAiwwJVNtqOXd6uK2LxB5onMu/jHnW/Tj5kFnvdxuMcBsP7qFDKTO8kqbUAwKfR1JJJ36S6QnRS8eQ2RvU8wqXANnrWpbO1IY/4P3+f4C/6KtuIuIh95qW1PY16yRECV2O3V+KDNTkfYS9C2lrlxIk/03sSW6Pf4gXLZN+5VR5Izzjhj+IrPnTh8tY+QQQnpqfKFuMVsnjK/xkz1FEyCSLJtALOkEFFlDnhdlIyqpuXxZDwDbjIdPla1J1CW4EHVRMYW72f5hyfQ8PYpLC7eQzhiIbvwANGglX6/k/4DmcQCegj69ueQ9OHtbL9/HH/71cX88LofsKouiZqBb5Pv7mfTjkksb0tkubcVi27lZMcY+iM65UodLhKw4yRedzIjPoFse4jtvbHMSenEbXaje61c8oMLeX7h6aw57WwWbPoRYvV+ymYnYcvrIPSdn2P76GG8HznRmiPsXjaTsXtuYKAmk7higY/XzqI9aIKBMKE7fsTK908gL7mdWHuA/NQ2+r1uVnfk0RWJkm61kGLT6VAj9MW9TaItl8c6X+Anys300DwYm2XYvPXWW8NX/MEbh6/2EXLYA+wnmo7jHM7nI6kcCZnpCWZskkSsLUDNQBxb2jLQgLcqJlNRM5p+n4tEp5dJ8T7mTaxAllR62pOo8ghMiO9hY90oPqgtoLclBVuch9nnvoczuQ9T+Xr0sEjSuR0EJp/G0vNO5proP+lqjMcfNRPVBd5rSaHe5+KAV6FFrcQneLggv5UZiQqZWjp35CTy2NR+bhrjZ05KF15FIqIJOCxhfFETv3r+bFprchhzbyvLm+tpbQ/Q8V4xAEJhKrb1j6M3eLHbgix/9kz2d6YiyCohvx2p2E6ae4DJcR4wCfTXZ+CNWOjxxDD5+A24Yz1kZzWz5NJ3KHCYmRgXZUq8h4GoRFdYJuKuZrm8iSflp7ERe7ibZVgtWrRo+Irf/PDw1T5CDjukN3IdDUlrWJBkZ45pDBm2CG6TyMb2NGLNEfyKiFXSMIsHx8LqukC8e4CpObWkPnML2X92MuBzcW1RK5OL9rOwpJySpC5yL98HPzsT7dQy9J+chdpiInTxpYTHzSTs66HvRBvK7VYK8+poCzhIswUpcEbY3G0h2SozR5rPRCmbHV1JzMpo4ju5KmFNJKrKjEppwxO24JJVYk0qLZ5YNnbLrO8N8sCWiaxtS+Okqz/mN847cCT34O+Mg74+6h/J5Lt3X8N9GyezfyCOwqQOhDlZKFEZJXsUE6Zt5/TlJqLTZ5NyUiUnTN2CwxJCjvUhWyJ0dSYSDVqJNetYxIPHbN+ZVIFV0nm10URuop/2lBUskY/uG5eXLVs2fMXXVAxf7SPksEKaxxjCuobFEsIiamQ5dByyQqpNpy1oYmxKK/1RiTRbkFGxfcwo2Y5FjlLfkUptRxrtlz5A/12tlN20lrFF+1EVCfevC5l92keEtpgRwgOIy7YhWJOIXH4ukq8LzR7H5iaFk+M8WE0R2ttTKEtroTi1hRyXl1SbzslpAyRZZHarzVR7TaxoyubNZhv9ERNtnhge2T6ezpCNHX1WmgIyP6vrIs0mEEFhZbCWdV0aVTUuRn/cwMobzsfsCBHcGkNPXxxTEyKclOYhz+VlQ3MO/hdDJGa3Ia7ahn3GAPa3n6b6hwKYJZrqspm0/Ns0rZ7C0yuP463qMeypLCLFquCQFVRdIKdsD8dntNBCD2ZRZ8DSgdPpY5p04mBtY8NR7rCOSUebJtEqtbO6I8KA4AVgVrLATZO2U1E9mnEL1tNTMYawKtHhd+LKayVXlWjdPpk09wCyJYKmiuhxCSRcFoSqKsTsH+Lt3sKmjVM54eSNKLf8jujNf8Se1oM80czAO7FUzz2P0zc+Q5eSQ15ePboqEQ5ZmJ7Wga5PZHN3PJIISVoi3WENHRlFV0mxhukJW0myaHzULjHapfO0ZxNpej4uk8b8eBeS4CKiQnsQ/P/spW9RCqdPrCd05rcofftF/E8sYltXMvOyOnGaw7TW5DD6pI3se2c2TqcfszlCU08So6rsVHWlkHDBQ0SjVqalttHuc9MbtLO+S2Zeisb2Pjsdz55Pb0RitAQJligxpigr5a2cJ17AZvWjQdnIhqPbYfWkRfpoPIKPHrGPbqEVr+hB1UVcKT3YzRFEdxgBiGoirUErWtCCK6sDT8SC2+EjZlQTZluY0Lthoun5qDPK0B+7ghueWcSHLSlU3ZdJ3Zkv01abjXDaGOjsJ+R1YE7woAQtxDh8fFhextVvzubJzVP5qLyMHb1xPN9fxR6/lzBRQqpGZ0jDr0Yp73Wyot3Kqu4IoiCwfKAHp5BIoh7Dqu4w+wY02gICi3KbmRDrI12O4Jed7Hz5RMRH3ke46gkmTNhDT0TGE7IzcVwlzT1JqH4r+9ozWF45nlDQSpLTQ6gzjlSnl6e3TEVVJfKzG8mM6SOqiai6Trw5ggC0h2QimkCGXcQuqQiCTlgMk0ji4GzhYTBsl1/gqLz88lUOqyct17Zwre1c+vR0doXNnBkfzz9qoDO4gCqPjfg353J+XjuBqInyXjvXPXIRt8/ezj6Pg1FeN927RiFbImzaOoWy3l0MdMfR2XsKd8zaQUJaJ2GfnYbmTMYU70eecidMgdj5zyPknEnowFY6e5J4rdFBt+rHabLyUK1OtklgPKMoihNpDwpsitRztjuHRp+Faq+CSRDoEfrZr7VQrI9jriORdJvCQNRMW1DAp+isbk1nTmo7px23ml+nljB23hZC3TFIqp/YSbUs2NXKrp4kpsd7mLNgJZwzkfEbGyk4fgscX0zW8jXomsDUOC+R5fMY8DuRJJW+gINEe4AHFuwn55UbuHDpzbS/kE1SyX5EW5RXHr2IlR0x+BSdHnoGaRMPvSVLlgzfZGSvrYZz5g1P7SPksHrS9dpykgIFJFjApduJsyhIgoBDVog3q5hkhaK8WsZn11McE2ZmUpBoVObuG55k+p07SD15D4mLmomxBXl34wzyziunN+AgJa8Zxy1ZJPzcRUJMP87rEj6raS24iDNkD+9cfR/TZ2whxyGSLNlp9Ju4JMNKlkNgbpJOuk2h0K1i0+1YRZ3xcRphTaVJG6CdWoq1cUyIsRLRwCodHNJnEqE3GmEgIpIU20fnLbPJypyE5e4HcZ0L8hM3ImTHMvOJPr41ey3ydwsRRB3dbCMQtDHpnoWsvC4fAC1sZvPHs7GZIrxXn0O/101IkanujyMcshCsfw08PjwDbkRbFCHJgiCAT9GJRmU0NXh4W3YYXXPNNcNX/Nf/HL7aR8hh9aQ6GhvVCs6PN3NiWjextgDFsWbG5DRwgi1I3G1uxEAUNuzmuKCN/En76KjORl84kVBMKuHXdtPekEHpqSvpeeUMfn3n9yh0+dAVCfPectSc0eTN3YP6qg3P47/A9r1U5O3lxM89ibaCB7D/+V6urHqc7oFY9vUmUt5rxSKBVxExizrNAYkZjmTq/bAn2Icm6Mi6xDhKuGmMn2RnO0/uy6UpYAIUEi06GTYTY2M9FJ+zlt8l/IOLP7lmKR5/Dxx/8OeOdq0lbtwmPH9SiBnrpeE2L4FIEqe7Mwgqvax742TsljB1nljiLSF29cMZgkZf2MrGbituUz4PTHMxNua7rO+SOb2+gAkprSiaSKxZYJxvFg9qdx7mpjUcKw77Eswvo7cSrDmLBLOGL2whqJjYUj2GdRWTqP6xmYHHwxxYPp3ihetY+fFcJFlFiUnF8u4y3l47m46+eORimVO/8yq3/+jvlObV8uLHxxPZJrH1Byn46tIxZw0AoJutCN95HD1jHldQw58Zw9h3r2D2/fsoTuii0B1lpyeA23Rw7iKTCONiImTZda7OtnJRqotp7hjGOK34o2bWtWaQZNWJauDTFGQBbLKGqguEvDZa3CXk4Cd0x4+I/vqGg2148gqqL6ynZeME3AUtiImQd/oW6vrjOSOnBasUZUtnCv/cn49DVoixhJgcrzMQPHgnT1lCGEHQyXcqjIntI94i0BiwomgSIVXC5kunSamkmurD3TSGY8RhjzjS0Lgoci5/Kn+ce6XfM0oezyZ9MwlCJlk1hfygKAVfxExWVxVNPhcFARvvn23HaT6L0+esI/avv0D7aBuYfWheE2lFB/jutF0Ip42huHsvkaAFZDC7fZhqdqP2/w4yxjIpO4O3yaCceIpGz2LWH7fQfGUsk90urFKYtZ0iyVbwKyKjXAHSHF7a/C5Cqkih20db0IauC4hAo1/lO7kqCdYeJhbUkHlxDT9PvoNrev9J0FeFFrJgGTWAtuZe1JIyig5s4+1lp5B+l4yyrALBpDImsZMYp5dI1ERUkzhlVBd72zOYfuIaihtTWbVzCr6oiURrCEUTOTm3jslXr2bPHZfxXpvGy1128jQ7M8Mm7tDvGIRNO3yWLl06fMX/dMPw1T5CBmVYYA/d/ED5Dj9XbqdOV9gkb8ZLL3uFfv5vXzGVYhUVz57H5ZN2sqMxD5OosqsngciWUkzTltIdnE+izQ/A5HGVxMb68D/Wi2wPsXPHBNhfyLQT1hIp1wi0RXE+cvAa4s/Ywz1MgORzKE2ez4U/uoITPh5LwGenxlvGouw2Wn0umgI2zJJKmsPLqg4HiubCKmkMRCWmJfYxPz1Mq8/F/OPXQFyIe85awUx6KfCvxrJ9C8rvfkq0+lXUZyoxxTWhRWPoj5hpvENgc+25ZLgGMMsKgaANmzVErC2AIOiYRBXLdHDTTt06B+U9EtvVLtx6LGf786n9XRJbe2S66WR2KItkzckd/AT9KJ+OpbS0dPiKF+cMX+0jZNBvVbuYS5jBbB40P0232EeWOJ5uoYVpwmTSbBLVvjC/ndrM+tYsANqCJkriPZz5QhPvXZLGjPG7cKb2smfzZGJdHrY35BHVRXrCFjxRiUUFNRTN2oZ5qoDudCEcfw+/ZRzpBPk2dYgvXQuRKDufnM/W1izyY/qp7o9jQdEeGjrS+LA5DYB5qV1U9MYTb46yYNwuqhqzyftVFX9Y+BI/ZC/Z9f9AfvZjDqybgsPpJ610L6H2eBB0tmyYhjdsYVRKG8/sHkd/ROD8/FaclhDPVeVT6AozJ6eOve1pVPS7KUvo44DXRUWfifZwBJ8eJs/iZGe0DYcmcFXwZJ7jeVax6pDWtXEXzBc4Bu+COSI3fccQww3cQAopPCO/hdfixK25CAhBWqhisW0OhW6FtZ18cjZY5KK8Hu7f5+D6UREcpgixtgAAGSkdKFETde1phBWZKYX7iYTNAKiqTDQqM+bSTay8+E1eJocFtHEKrdhQUTfdjzT9NgLty7G9+xzRaTMxNR+g/LeTmLRgHV27C3CndRG5/24e9Fgxq0F+tOke5G1enn3+XKq9NmJMKpIAqbYQF9/4DEKKkxW/OxFP2EJ/xMJ+j500W5RTx1Ty/K6JlPfqzE/WGBPbz+6+OD7q0Li+0Mvm7ngiKhyX2sNL9YloARezI/m06HU8zMP48B3yejZC+gWMkB4aK1au4ApGCWOpo5Y39NdoogGHJZ8F5pPZodcy3zKK9pBCSFPoEvo5PS6FvQMaxTEiLQGBcbEKnSGZrhBYJDg3p4NNXUlYJQ2ToBNrjlKS3kT+uCocMzt5f/rVrM+7ghAisUSZSjcz6Cay/xnMYy4FQF/2E9rPeIgK4thAIuZgA6VXvsF557/M+78++bP2myWV7oCdNJeHdxozmZXcSzAqU5DQxTP7R6HqMCkuQKotwPbeONqDEiEVWoJRCl0m+iI6HeEoF2QrPNsg0sA+rle/h01RqdC28A+eIsI3n07FCOkXMEL6zeWQw/mcRwbp1FBHhbWd7doOLLILgBKmsjLyOjY5HkGQyBMm4RM8pGjJOAQT3bqPLDmGWJNIb0SlT40wym6jyK2g6tAalJmReHBo4vSCKqpbMhm/cDe7Tx3DrmAR+sRspKQS9IaVCD3dWHLzKP7zR7QujSHF7CWiyhRnNSAIOr39sYSiZgIRM3/em8hFuUGeqjWjozPObSXWrPFKbyvFYjoT4+CdLi8FZjcJVoH13l4cuhW7YMKnhWnSd3Gxfglpig2P1smbLGUb2wZlnY7UkF599dUsWbJkeIrf+zTccdnw1D4MIyKk/y6XXOYyh/GMR0SkmVbWitso19bw6WMhBMGC25qPLFiwCE4UwrhJIl/PoEHoIEdPoUnoYqKchlc5OLeQJAj4VZUzMjTskkpBbC89AQdNAQcm4eCc9HZJJaBKxJiipDu9NHhiSLQF2dYdR0dIxCrBHk+EJLOJurCPdqmVMrGQteo2wpoPuxiHHTd1wbXEWHPxRw9O4ekyp9EbrCLfUspcbQZjwwmARD/dvM077GDHoK/HkRpSw6EbcSH9vCyyOI55TGIS4U++VrOOTWwkLKig/+uRDy5rAd5wHTZzOi45FU+0lTTTOCxYCQhe+tVW7GIc2VoBHtGLqIsMiD2MUgswCxImUcSrRkk0mQlrOrupwaRb8NNPd7gKAKsciyiY0HUVUTDhlBJpD+5CUfsxy0mYJAeBSBOFjCVNj2UqZSSRjAD00ssa1rKOdUf8LO1IDWlpaSnl5eXDU/ySX8GzR99AkBEf0s9z4mQ+85lKGXbsRInSRTcNNLKXfXgI0Sr866FAZjmeqDKAIMjIkgNVC2MzxRNRD17WkUQzZtFJRPN9FmxFC6KoXkTBgiTaDr5HcuINNx2cvV4LfvZagXkyzoCHaUwmhRRs2PHjo5VWmmhmDWvw4x/ySycjNaTGMemhG8GPmfhiPnws++TrUwkkUEghExhLBpm4dRdOXEQI0xhtYSUraNJbCOEFXcMXqgNB5NNBVWHBgo5GKNqDrgXRURFFJ5oeRFcVEvUczJEI6WQzkxnEE0uMHotJk/EoHqqo4mVewYOHEKFhWjOG/0UjMqRfpIceNrCBDZ/7ewGBfPKZw2wuJh9N0z77e6fuwosX0D+ZiE/g0xn5LFjQNf2zs6shNUQ77ejorGQFPnx0fm7WQMPXk5aWNnzFE2OGr/YRctSE9L/R0TnwyZdhZGhtbR2+4u//YfhqHyHGk74Ng+7uu+8evuKPDuO44SPECKlh0N1zzz3DV3zJME4neoQYITUYRjgjpAbDCHfUnzgyjDxH5Fpt6VWDv8yjhNGTGgwjnNGTGgZdWVnZkRtx9GWjiY7R3tboSQ2GEc4IqcEwwhkhNQy6u+66a7ibcEwxQmoYdMM64ugYZITUMOjS09OHuwnHFCOkhkHX1tY23E04phghNRhGOCOkhkFXUlIy3E04phghNQy6YZvf6BhlhNQw6Ibt2aTHKCOkhkH32GNH30RgI5kRUoNhhDNCajCMcEZIDYOupaXlq99k+NqMkBoGnXF2d3AZITUMusWLFw93E44pRkgNhhHOCKnBMMIZITUMukcffXS4m3BMMUJqGHTGiKPBZUxEZhh0w/roQ/h6E5IdRY9HNHpSg2GEM3pSw7Gj/LGvfojwUTjtpxFSw38QBOGr3/Rvvmi39owzzhis5hy6uROHr/YRYuzuGgbdW28N45PNHrxx+GofIUZIDV9I1/Uv/f4yixYtGqJWfoGbHx6+2keIEVLDoFu2bNnwFV9TMXy1jxAjpAbDCPc/E9IUUriXXw13M4aVIAhf+T3SHe3t/yaOibO7Z7KYMYxhP/tZzwa66GIOc8gmi81s4VquoY8+sshkPvMpo5RlvM2pnMKfeBCA0YxmHnMREPg7jw/vD3SUG86BDMK2v6Nz9AxU+DqGJKRZZOHCBcBYikkjHQETOlHg621QP342sumz/1dR2c9+ABZwErfyY6Yygyu5lnSSGUU+a1nHOZxNkVBMWNJ4ImsVv677DfHEkSQXME0pwkkMMcRSxT5Ws4ofcyuP8wQ6Onbs5JL3WRszyKCIMYfwkx/8ze7Fw2a2ABAhQg01h7CMwXekQ7RkyZIjNjTwy9ouCAJXJRzK9jk6CF/+Q8uHtDWdOJlCGbOZRSIJeBkAoI8+WmkFoIlmasVucq3T6NGb6Q/WABogfhJaFZAAkEUXcdZ8Akof8aqNsXoRquZDEp24BRcFwijCqo8eycvqpG6SUlJQ54+iKzWejCYbHY4gSpyN/JCOyS8QP2cAvUok2O1mc2aUGVuc9I/20hcTpa8tSKC+lfErGljQW4agi5gxs0+spzGyGRDxiWE2ais4GD79C/77n0TBCUCq7qaYIgDiiSeddHR0nLiICiK79C28zwf00nsoqxtdV/5j/66srEz/sqdsf7o7OBgh/bJlHZFhgZ8OQviSgQqCIKCXXPn1BjOMsGGBgiCU67pe9kWvHXZPmk0ei4WzGSeVIGKlSWzjJek1+kU/nmgrihpE0yO4LFkkiDn06yHCKkQBTbLjcBYT0QOM1sayTfuYUKSLy+K/Q7xZZ0O/H1EX6TBZmeLMZXxslHp/IjMSvWzsU6g6KUp12XiiFhOZAR+J7T2UVW1j95sCzV1BfHoLbi2GGFsM/VENx7MC2Y4ob7cK9AjlvA2M1yaTbrEQjreiZ8VSccUM1qVYyPToXPD2ar7t3kFzbyKP7o9jSqyI3P8tzKKIKIBdElgXridJS2Rj8FkE0YYsOtD0MJquIIkhBCQG9HawFFGv7iCq+gGIKF0IgkSJ9TyEUDPf5yZidTv99LOFrXzAB4e7aQzHiMMKqRUHv5f/wqvSChpMazGLIoqu06/5kbGQah6HqIsM6O2cZp3FyWleNnTns9bbzWxXPAd8buYlQ0QTuGDcbtbUHk+CJcTfaxR+MmM3J7SnE1JknGYr9Z4g45M6OCe5E1+mhRXfuwztzyG46232h9ezRwsxUZjNW+JO+kP1JFhHMxBtRtMU7JxOv+Dj7c4PmGU+hz3CNvqCNWhagLVSLQniGHwtXYQb+pHWWyiTF9KWAVvvPpNRoU7Oll/k+FoX5ulmyu+bwmsH8jmnoBaABb1JdAQtjOm/BocME2KD7Bmw0RPW2R3uoU/swq3F8ftigb/tX0CTNICGRqX+AYraj1f0ckDYxW65nlCkmRjiuUK+Hkmx8C7DOCjAMGIcVkh/arqXlfJm9guNBHQfkipza1Y8t6fEsaMjnZPG7ubmD0opis3DIauceeqHzG1MJWfrVKalNFGQ3YiqSjjjBnBdG0tBZAvi3n08dP3lPFMxkfPGVCGKKvHxfcwtbKR1ZyFZC7bxxOTvcflzbxDZY6E2JZZ3WmaR7Ra5uLCWnR2TeLJxHKPMLnLiSpBFnfagSESzUmy6iPqIjzOss1Ass+iJKLTrHkyaTEjK4sT4ZCRBZ3FuExVdKbT/4kOWf3gcJbdUk3PWNvRanTZvLNv7FBZrEnk5jdT1JXLOlHKEHSXUeM2kO3zYZIWxSe182JDH7v4Ezs7qZ1R6PRdHrNR63bzbEeWK+Iup9AVJkayMsl1IWNcoijMTY9JpD/Zy8cBVrFdWM/DJIcPRZOnSpcNWe9GBD465X22HFdJuoYfZ0el0yv2skzYCkGizMXrCPnwhG1nHb8O8fComAXrDEp7WJDwDbloCJt5tzGSCJ5beiBmHrGBarxFSJfrCs0kxS+zp12F/IZ6oSGdQJ23VHCoHolxVV8CUwgZuXPwTPD21TGvsJNBYz+6BKP/Yl8+0BD8zY13EmlUumlhBbVsabzWlYpfhzOxerqmq5eKEiXzQJpNhk+n2S8iICJ9cjarz6dwdmILt7NHsHJPF9656j2cOlFBYU0i118mTPXUoYju3ledgLU8jxWLmmbqpVOst5OhpyK1J2GWdtkAeFX0SXZEoUU2kuTOZsCoRUkV8QhCXyUqyyYJdFogxy/ijOhPjAsQIMoU9JyEioH3Nk2ojTWlp6bDVLg90D1vtI+WwTxxJyFwj3MhExvOy/iJhk41W0wBdWgtOKZl2/yb0T/6xCYIEuoaOyhef1RUwyYm4zOkElb7Pjt9UzYsgWIi15pMRdpIkZzGOSdgTYomPy0aJcyAgYBat3LK6lMnXPEaOksWZlYVE1SDmiEZD7ADZoXTa5FaCZp1J7QlUpHTxl+P3886jp1Gd0EtdnBdn1IIWCuNvrkLt9/OhugxJsrMxugodBeBg+/WDf7ZZMgmEGwCIt0/EH+0ixpxJp3/LZz+j8G+/Cz9dF7IUi64rCIJMlp5BupjFjaYr0SNW7lBv5QB7vmrVGyeOvqiuceLo/6ei8Ij+J0yYOIETsEVVjo/OQUTEiRMfJ2LGfPDs7tfZbsrB7ySSPvsH7cSJT/dBAFpooU1tZytL2dG6g0hrBBUVgBM4geP4Dd9+1McalvAgddzB7XzAh6SRxvF8BzN53MZPcDKRf1T+lZtWfJdylpLXksdl/GvMqQ0biSQykYnEqA5O5odoaJ/8TD4ATJhoC//bszgDn/w3KgBfuL6RkUkllZAa+mxZffRxQKvlduVWajlwiFvAcKwb1Esw/40Z82fXSb+uECH8+A/pMyIiNmxf+DkZmSyyqKPu/3vNggUZ+ZDrWbDgxHlInwHooeeQP/NFjJ70C+oaPek3EyEyaP8wv4yG9l+DpqB8YUABwp98Hapv+rlj3VVXDd+N1Uu693GszbD0PzN21zB0lixZMmy1r2lcO2y1jxQjpIZBN5xnd7cWnTVstY8UI6SGQbdt27Zhq11qTxy22keKEVKDYYQzQmoYdGlpaV/7vV/nHtdDuU+0NXJoZ+iPBsfE/aSGkaW1tXXYamfsfh6d5776jV93as8RcKnG6EkNg+7uu+8+5M8czsRn/+6utJJDrj3SGT2pYdDdc8893yiog+Hurwrp1+0ZR9Ak2kZPajCMcEZPajgs/+2kzrE6KdhwMHpSwzGldO/rw92EQWeE1PCNfNlJnq1bt37liaBvemLof5Gxu2sYdGVlZQeDNwwnX8qLzx7ymkea0ZMaDCOc0ZMeS/Y2fGnvpZdcefAPQ9HD/XuNIR4QMBgnrYZ0XX2FIbnp23BkfP6mb0EQuoCGQVh0IjBYkwWNxGWNxDbl6Lqe9EUvGCE9in0+pINFEISt/22WgGNhWSOxTV/GOCY1GEY4oyc9in2+JzWbzbrJZDrs5SqKgiwPzumKkbiskdimQCAQ1XXd/IUvfvm1K0k3vkfu9+e3V2lpqT4YBms5I3VZI7FNwFb9v+TQ2N01GEY4I6QGwwhnhNTw/xnMZ4uOxGWNxDZ9GePE0VHsUCfHHkqqqnLaorOob2hg8/o1xMTEDHeTRrQvmxzb6EkNg07Xda657nq21LTSbc/htMVnE4lEhrtZRy0jpIZB97vf388rby/HefpPcB5/FXu7Qlz23e8Zd7t8Q0ZIDYPqhRde5Ne//yPOxXciWhwIooTzlFt4b205d/ziruFu3lHJCKlh0KxZs4Yrr70O95k/R3b/a5Jq0WzFtfh2Hnr0cf7++OPD2MKjk3Hi6Cg20k4cTZhSSlVVNY64g+PELRMWornTiK57CoCQbwBBCdPX24PZ/MWDa/5XDftT1Qz/G95btpS+vj4A3n33Xf7w7Dv4G/fyrVOO54c33wyAzWY7cgFdvRPmTToyyx5GRkgNgyYjI4OMjAwA9uw5+KRyU0IWSUnJjB8//sg34BgMKBjHpIYjLFC9YeiK3fv00NUaQkZIDUdUpL1m6Iq9vmboag0hI6QGwwh3jByTfnqSU0cQzKBrSJILVfOj6yoCAggi6Bqi6EBHA11D0wOffc5gGKmOkpAKCIIFSbRhxoGEwIniSVhEBxkRJzG4MYkOHNgICBFULYxDTCAqhgkqPQBYpVhUPYpJtBHVAjh1K+OFIlbra9EFnS36FmppoEHsIKR1o6N+UtsI8OFwTzt36Iq9d//Q1RpCIyykB3tEUbDjtuRyhn4mkqAxX5mBhopX8KNoPhRJpoEuzILIZus+Dohr0FBxkUCrsgezyUmimEMAD51aJZJoIdlShF130aTsJBBtwGJKQxRkgpFGXHo8ZebjOV45iUzSEUUBCxYison3Ii9SL3VRr+76pI1GaA+F6usZumJ7GyApdujqDZFhDakgmNF1FbuQwNmWKzhZm0ahzU69X0NTFZpNLXgJsMq1nHirxrb+MAkmCzFmgSp/kAAheqUe0GG0NpY8m42oKYe5yWGmpTeRkuLF7yvixd0TMAk6ZxVX8sbehXzcqbEgReSJzlZqlD5ctnFU0sLK6FuYpHgk0YyiBUkX8phqnU5J2EGGcBW6KBIVBbbqm9kjVFGj7UXTImj6sffg2sHir1wJi2cOTbEf/t+IeJ7oYBvykEpiDBOtpzBXKWGGPpYE2UJbNEBcXAOZBf8gKkTI0CSqehPZ0GxDFGCUXeD80TWcr0lUdKai6wLzklXmFlXzZsVk+iMy05K6cVs7aRyII84SZPING4iOmUTyu1uZ15OIyxqkeyCWs8fuYWGejagqc1phgLrO03iz6eAQtjptPJ1CHwl6LKdnSjze0UaN3k2FvR4f68jS8ugW2zghOper9ROZak/Gp+hsVet5S3+dnVoFEa0PXQ8N9WodkaIB73A34ZgwJCEVRRdF1pM4WzmeuWIx4xK6CaetY83AASqiIIk655y9lKjfxs9fOZ07TlpDXlYTp5Uq2BP78XfFEw5Z0FSRS56QsGz9GD0pGUSRK99ZSkvlKBLSOolfcgfTN/yO3Xdm0PVGNokzNzBQncfksh24prXy+K+/jcMSIjm5i8aWDIovWkdxXAyz34lFNCkMtCeyfPdEAqrA4knl5FYVkeYaQBR0VjWPZVe/RFw0n4y0Vhy2Ot7w2Ch2B6ltTOWM6Dnca/khA1HwiP18xE4+kD+gJ7DnfzK0EydOJNWm0QfMnjVruJtzVDuiIRWQKbGdykOWK0kzizwfOMADyivcm1+PwxYkJpKOR3NyavFubBN6oSKRH80oJ+W4PSjTyjBNug5txV34HhcIBa2MvngLgeRbgI8Rj78H9Y9XITutJKR1Eltay8B199BWn8m4azdRF1/Ih7HfZd+UXAJNCUQiZpY/OZ1b9i9BaB5Pcm8XjUunUNuSSVFeLYoiY3f7aAlaiDMrOGI9ZMf2MnnhauSyWMYt28WWTWW0+lyk2H1YZIVRMQK7exP5zuTdvFk3QGfCWvpCFno8KdwkFnGHMotOWefJ0GbKpT3sC69GUYfwGG0YFRcXU7lzG0uWLGHRojOGpujPvz00dYbYERlgL4ouLjJfzwnKVKySyFrbOnxikCSLzln5jZglhYgqU1S8H+vdU1HvW4vz+AHUrHz092qQx2jgcBLZFKFh6zjSChqxpvag+q3s21CC2+XFGesBoLsjiY7+eOb9cR/1YxbzzA4XzUoOE7y7EJ7ROMW1lmR3O0+9fzLbdDcnTQmg5ctUjC8mnGSicn8KZW9v4WJ1A/6wldWtGXzYEeVn4/rpD9vIj+8iOakbiz2If8BF2rgaBFGnvy6D5HmVVL0xC10XKG/KxW2OcMYNL/PKgxdx3m0v8sYfzidWFvE0z2SKKQ5vII5H/OWskbdSGXgLPjuD/M2MtAH2hm/uywbYD3pIk8xj+bv5XhYU1/On1mbKvUHOyAhS47VzZsEBxj1uQkspwe4oQFt1D+Jxd6G/cRPCWQ+hPnQljStKyJy2m0BLErI1gjW9G2YWoCRmEvrTAdxnh1Hjk5FLbybyqxuRYoK0rJ3IW49eRX2jl/zr6+lq1ugMieQ5o7QFTYyLCfBgo4erM+KYk1VPY18iSQ4vNb2JhOwWPjj3eKIuCz986Sm6+l1s7o4hwaKythNGuWRkQWdMTJArHngHbW8f0o8eo//7v8SZ14r8478R/PmtWOfJCAt/B0DtWX/FZI5SWZdH2aRdeHtj2NOQx8SsNvz7F1KcFsP7FTH8LriStaEXvvGJp6MhpIIgDN3N3qVXHbUnjobkLhhBMPND5+1cph+Pr+AF2rK2MtA6lWSryKU3/RM0CNUnIj0fwDyjAk78FUJNA3rgxwhnPQRA08opvLBzCo3ry0i1apQk9rHwrHcw9XZjbqijobEM24ZdCKZ+9N7bkU7KoHG5iQdu/y5n/fNdrvZ+zIv955DgVil0C6zqcBNRYUWHDb/YyqbuFLb3jkEUIM0Wx6K8OhRNon/JSqqy07n5qlv46Vv/ZGF9O88dSCPDDvnOCDv6zJgEnWdvO4VxyW1MTvweW7ediXnneKb23cbvnjuPn/IKZudvUN7vYnv9qQQVmbLsOprqshl3wka8PhcZP2xm4LknUS9UKL53Gs/VnENIPYlz+15nZ/BVDrdnNRybBqknlfiL66+ck2RiV8IyqgdikUWNufnVjP7OdpBlQiUnobmzMf91CR07C2luTccXtjL31I8xnZhI8E0/TZWjqO9KYXV7EnZZI8MW5ju/e4OGp0ZT15ZBd8DBWRe8iTQniYYHkxAW9HDf2Nu54cWncPf48XqdPLJ9PH7lYKt2hDrxiH2UiqPpjUbYK+4hWc/CpJs4IymGdFsYm6yQ7vTii1jYGEjhnWtO4Z72F+h/SyDRFmBC/gFWVY7nW5e8wkevnUZ5dwJnFNSQkNjDpn1jafQ5MIk6afYAM4v3UNOQQ4s3hlPnrMN1qUzFnTnkj61C+eTE19Nr5nLjW/sRfX1U/SKO3NQopi3X8JcGP7cFbkbXv/5cQEZP+jnHaE86CGN3Ba6w/py5tjh2Jb6FXzEhixpl6U14/Q7UgmLo82HLXowjdjLKJaeQ+cLNTL95NdOmbyXUHUP0wx5eemchD5VPYOEvV/OLy19kdmoHp5VuRW/ykDmrguq+eBymCEue/haNf07k6W0l/CT+D9z+0f3sWZdNbVMWLpePNJtKmk1HEqCFKkK6DwAfYTzRVtqEWnyilxqvwI4+G31hC6tbUwlGZfa1Rsi88w1eLTgF75REbKYoqiLREbKwZ/ksUt39xJhU0jJb6euNpydkZVZGM/s8ZmxyFLM9RIzdz3kXv0rl7mJeu24q9b2J3Pnq6diT+qitzSOkinTe40FJyKbotHXYTt/JE9HVuAUrS+RnsYmph79JRpAzzhiik0YAcycOXa0hdNghnWA7jVsd06lJe42IKtEdtOGQFaKKTFV3CpHnW3j895fz9+JVVJ76BMF7K1DX/QZsdlwlLQR6Y4h67SRYg3iiOq/8dAEfvrsAER2TLUSwLoW/PHoZFf1WAKySitUewnFdCuf1LqV82WQKkzpY35HKt9+exLJOP50hgZZgFE+4mf5II23RABEhikVyk6bnk6Wn8mbgfWLNOqouUDkg8EqjC5skYJNE2n74MS8vOhWvy8G33y+mMyQTVky8W1dAT1hm6+7x/Hl7ETrQF3CQYVdJcnqJm3CAwqkVmH72CAW5DQQVmZAqMykuQN2OYibO2srPbn2M6oZctl0OkdNOQjn7fsr7rHwsbyUcd4B3rM9iEmIPd7OMGG+99dbQFXvwxqGrNYQOc3dX4BXzMopnPkZK0S6e/ugEIqqIVxExiTouWWN2RiNb2jLxKhLJ1jCZTi9hReaUy19DjAe1xcQrz55LmsOL1RxBFHS6fC5Gp7XgjvXw1taptIfMTInvw2kOM+/6t4l0yXx/yt+Zes0KYs0Hdw//VKtQSwUhtZ8CeTomzFSEljHOegoRIcJkOYPjUsKk2v08tN/B+VnQHTYRY1J5r02kW/Nz99gwSxuTyXKoTJ7q4ZXTT6fw7tWs7xa4NM/HsuYYVF2nNRzm/EwBlylKtddOX0SkP6KTaBE4O68JgP6QnQk5texqyKcnZKUwvpsxY6qJX9xJx0tZdHUmEQhbGDN2Pys2TCfWFkTXBUx9xbS3TuYi//lfufGOht3dRYsWDV1Qb374qA3qETtxlC1PJNGmITq7EASdzpAJl6zSFhRRNciwi6xpzqYkqZPU+B4Kz1rPw/dfweLxO+nbWYBsjmL+wyWcsOdV7In92LI7EcfE0/FsCt1dCdQ1ZNMeMnPJ5O3kfruSgQ+TCe9z84HjVM7wv8ZKTypxZhPru6O0i3VIugmz6CAshNgfWkm8rRBN16iPbKGfDgoCJdR4LUhClA/aZHbqtaSoKWyPfsCVCeeyvUfFE9VpCUhMqY3StytKwkIHY5eFWNEeQ0l8lDhzhGS7n2DUxI6+GJr9ItkOjTyHyuYeGUWTSIntxSSphEJWsuO62VY9mkkpEdqa0omXekmeuwfWjOO+j+cysy+eKTl1+AN2FFWi1XGAMY4JFIdnslcZwhumj5Bly5YNXbE1FUNXawgdVkjLTMfhTN1KeUM+A9VFtAcFCpIinFVcSeF563nr4fN5siaWsXEyaQWNhBaexXkfb8FkDWNPGMDXHo/lN38lEskkcZEJzT0efWMFtQ1T2dKejqJDhi3MczumUHCgkAzXAI2eWKq+O5FTX/+YcTEhusMm8h0W4iMTKNcOUEA2XboHpzmNKXopUV2lz1xAV3gfHaFSYkw6Pj3MqsBrJFvHsjn0AiYpno98zXh9vUxmLElWmUf2xdPSsIpX7ziLqze8yFn3raD+b9k8sKGMc90DNHjdbOxRyLKZSbRGiagiXZEwEUWivisFs6TSNBBHRBOZFN/PqAn7kKxh9OZeVj21mIgiYRZ1esJWHt02GVWHibEBVF1gpbKNbwuXcDtHf0gNh++wjknHqgVI9m4GImZaAhai2sFjxpTsVtTJU3CaIwQ0FVUXka0RECXSLm1BEHUsqT2EgjZqtkxEFHSErk6kzlb+8ZfLuGxnlHR7gG09Mk5TlFRbmNzYXnRdYHuvi3ZvDDEpPcSYI2TZQygabNWqCOoDDOhBRERipQyqxQa2s4H24A4UpY8XvO/xt9532Bx8Dl1XaAtsIcZayHzzYmZYMonTk2nVPbQHdcK6htMPLZKNeFsA2rrIe/06zs1rJdbmJ9c1wGV5YWYkBmkLmnmnTSNWNmMzRRkIW+kL2ajzOegLWyhOb8ae0441txut30KL140nYsUh68SaIwQU6Arp9ITNRDWRPvwk68mDtY0NR7nD6knX66s4yzeFhkAba3r9fDtLJsXhQzQpPHbhZJJtQb4/2kdWfA/ddRm8PD+WH/3VzIGafKYdf4CenngKX8xBuecA+58qIza+n1NLyoFSUp09ZDvddIasdATN7OzL5ezcVq6YuJtlqal0ladhl6P8o9ZGF70IokRY8+EVvWTqyaAdbKNDcLJf6EAXRWxyLAAF0lQ6hSYcxHGKM5/+iM6k+AiBrhQcssD+wMEzwq1SC1kWDVlSqX19GmkXNDAqq5GE3FYmT+wmNOc07p6TgaoLXJyjUpJeT0ZOM9l9btZWFQOwaOIOYpN7eOHJC9F1AZusMCaxk+TEbk7NbsUxrp3zJ0/kte+Ooz9ioTNswiRCv+A5nE0zYgzprPVH6eWXr3JYPem66DuEO6YRUgWCQgSHKYog6OiKRKI1hIjOxJw6skfVIcsKRTED4PXQ5omh+6NRTP7Ox2BLwvT7K8h+IofUZ24hNreFy/fMIT2xmznJPVglleIYHyXxfhRVJD23mdN5hVeKT2NdZzwOSWKcJZ4CLZupwiz66SCsqyTgpFtsQxEURlvnkWmfijfSxlhtMtPsyVwaU8JcSz6bPQO87l/GfW276IiEKQ92YkKm2OHkrMISxkdaSIzpx+n24rv2RcqrC7GV9BGeeSKaI5n+iMDEWD9OUxRNE3nwwxO4Z/VUYixhEiwRXthWwuatUwgqMrU+O51BG96QDQDZHgJJIFwwH6c5giRqaLqAroqghQdlAw+3JUuWDF2x11YPXa0hdFghDRNiS7CV89MC/H58mPEprWQkdLG7YhxnvBXkrJtfIvfULbjO1xAljeKsBugLEGcN0tGaCilJ1J27geitT/HwLDsD191DoDOeurMeR9MEpk7YRXfITHvQSkvAyriCA9TsHU3T3wvRp2pcXbqDGYka81ICqLqGWRSZLU3BKZrw6CHy1QK69UbcmouTrGPQdY3N6vu8E9zB8wO72BpqJyJECSt9JOoZbNdX0yd2sU/cxdZAN7vmT+CSzpcRBB13djs+j4vjpm1BH4gihnyID77BOTkddIXNPFgjUt+biFXSyLLrxFoDTE5pxSFrdAcdABzwivREZCp7E1i/v5iOffnsf2kW5qaNFGc1MC6xk8nxfZQGpvOS+o9B2cDD7Zprrhm6Yr/+59DVGkKHPSzw9uj1LN3zLvEzf0MoasZijiAIOuaWSvw7U/F3x6GvEXCldpOY2ovaZ2LeLR/S+MJY1J397G3PYGtzDonWCO+vncUBnxNPVGTfwMH91csLBhib0cSu5hz+uWk6czNaWHDJG0QmHcfaHxdy+d9X8/qGWcTIZuYlqyg6rO0USZYcxJsl8pjFgWCQCr+Hsx3nIAjgiapUCvX4hAE0NJzmdDxiHy4hlVQ1k+nuGNwmnYp5CaQ93UNUMGPJ7iUnYYDq5TMQRB1hZyt7d0/j1YYUpicG+L/p7QQiFkYld1DVmUpybB+jF6+n9JonCP78VnavK+Ps2bV0tabQ44nBF7bQ2Z2IKGjIrdUEQ4VY5CgdvdmEo/1sZvNhb1zDseGwBzMECHBd5Gp2r7uOq8stnLMmhv6gnZ6/inTVZ9DUlEF7WwqmGB+cOJ5IZxy43LyyYwqR7ljOWbKDVLsfq6SiIZBkiZBqVVB1nfNyAgQVE8/vmsD7rbFcecJKSv8eQEwWWXj/L6iQJxH8jo2Tx+7i7KwAVkklpIpkOyT8ahRNh+IYhUKHjYkON3kuSLUJSIJArBaPX+9D1aOkSUW4tTi+Fz+eHJMbTxRar5vGdze8RGV9HhVNufRtGUX9qjKe3jWePbvG8se3F7KsPofjU7wUxXcTF9tPMGqmYHIlxWnNJGe2oXQ60P5yBf116cS6PMSMbiItt5n0pE5ykztY3ZzF3q5U2p5KYW9bJl2do6C5mNu1WwZj2xqOEYMypWcV+7lXuYWbAqdiCfWwvz+WuoYcErLaKb12JaMm7kULm5Cn3IglvZvw6FK+e8IK2qtyqPllHAWprewdcCKic9lFr1IU28s/Lv6I8859iwM+O5KoMz0xgKpIDPy2nRUPnc7mj+Zw3cPPc/+Uu5Beu41LfvAMWU4vF4zfxS/PfpdLc1W6wlHKeyXmJftItWl0hgRcskZxjEiWGEMZZYzTi8nUk8kVk7hm7jpOywgQvqKEQEikaGctNlOUoCJTfyCXl3ZNZL9HZ3VrBidltnBGbgMOU4QWTwx2t4/VbSlEfTYCQRtV+wqJXnMugQOpNDRnoqoSSBqqIpExZR8F88opju3HbQ7T2pbK/toS6vaXcrN2LWGOjeNRgKVLlw5dsT/dMHS1htCgzbtbQw038wNOU+dgaprD6sYcBtoTIaKwfXMJteXjCf7sNqSb/441/3zil9xB3gXbiYkbwGINMyeli8KkDsy/eIiTNp2M/dY81Ntu5PKpW8h1BJmbX013RxJmWxhVE1jdmo7SZ+H+lVfyh84wq1PmMC63Dos1zM4dExCBE1MhwSIwLrmNDFuETLvGrJROQqqAVRLRdJ14k8zp6XDzuA46o0lsWTKDhTE7ePDA/TR0JZOf0UxUE3ly7yhmpHQwKQ4ybCHmXPMOAJMLajhl/hrib7RQktBHT2sy2bmN6LqAI3k+zj/+hnj3AKKoIcVFiTutE8kdQHSHKUhpY0dXMts2XEqjby/Xq987pgIKUFpaOnTFinOGrtYQOiI3feeRxw+E25DlOB43v0YLDTwyqoCesJXLr3ge7fTpaM/uRj43D9HTi+9VFeeZOvrxdyCJFvz9O7BveQl6eghui+PFZadw6Yv7qP2pTEtPEqomMCqjmdSiOnZvKMUftlB1dwo7Y0o45Zl11H1gYXpaC+kpHXR2JaLpIpnprdQ2ZtMTcPBeSwKyeHBuwgy7wvysRtadM5WGs7P4yUe/IL4+hHm2HerbqX5zJi/vGY9fEbnj4lcRTQqd+/NIKmzA5PYTao9H+NVl2Df8g/X3lJAY00/OlEpad48m75o6Ah9JWJL6qV1TQs6fbOiixH0n5JEq2DG3zsKntPAAv6eZ5kNez0fDsEDjLpivZ0hv+v53GWRwA9ejI1FhaeFd9S0w2fht1kzMkorLFOWUk1YgSCpRvw1rvAftirmYXvwQYX4+oTELEO97FttvD86nqr9xExX/NxW3y0ve69ehbH+Y0D/bMH8vj2j6FMTNb/KEcBYVwTISLN2MOqmIxEtfYIy3jqgiU92RxhnfepO6dVOw5nlpz4/nH67LiGTITP54D9eVPki0yoJ+0TQsoy89+Mtiw3MMLHUiW8NI1gjb105j5o0fs/WR40hLbcdsDeNI7Mfk9rNrxQya+uMxSyox1iAZyR0kj25A+P4MHjkphYgqEefPI9LnJqD28DAP0UHHN16/Rkg/xwjpN2fBwhzmsJCT0RCps4T4UPyQTEZTFmshrAm0BDROzQgxI7uOlIx2tKjEuopJbOyO5bxRdeSPquXOt07CE9WxSgLn5HRRNnYPG3dPYMb4XcjWCJI5iru0iUhdDMEEgSptAhtLJtIRyqKvI4mkk0PoZitiXR3B5gRyGpqZVrGT0nkfoedkIx73rydR+z17iNz2Gpoq4UzvQv3JDXDPY0jWMOa8AT7621nkJLfzp82T6QnrLEgLYZMVVne4iDHp5DgjnDZ2F3/fUobDl4Mp6MQWjbKZjbzKa4OyW2uE9HOMkA4OK1bmMpdpTCWOBDxiiD2mJtbpa8mRSkiVHSRYREKqTnXIS4/YTaaWTofYTbaeQrxJZotSR4GehUkQiDVLJFgEpid6cJki5CZ1kFVYh2wL0bxnNKn5TbimNKN2WljzxkKSY/oo/lkjgmcAvbWf+nenEpvcg7c3Fq/XSShsYX1rFt6ohCcq0haEgKKT5RDZ54liEgQy7DJNAQWHJGGRYGe4gy6hibHaBLqEPuJ1C7O0EnK0NLzRFrZRzru8h4fBHUV0NIT06quvHroBDfc+DXdcNjS1BtmICunnxRLLVKYyg+nEEEeQCPvlJsrN1RwI7wIB0qzj6YxUoekKVjkWf6QNmykRi+QmoPSQLo8jTounyObGLEJEg5mJIbrCJlwmlc6QiVGuAJ6oiTyXF0nQqPHEENUETKJOf0TGFxXwKgJb/L30i73IuoyETD8dZGujqWY7LimZtuBO4q0FBNU+YsVUEvR4pmklZEed2HSZiO7nAAdYySpqOLJPFDsaQmr4ekZ0SD9PRKSEEuZzHEkkISIRIMIG1tFAHXvZi4D82QOZ7OYsYuR0APqVJkLRHtA1MhzTSVJT6ZV6cGhOOoR6FC2MLFqwCi5CuhcJEz6lC4vkJFZIx08fNiEGlShOPYagEMCluWnRq9DCfUxjCqO0dPLJx4cfEzLddLOGtexlL36Gdib7oyGkpaWllJeXD02xS34Fz945NLUG2VEV0i9iwUIZZRQymiyycOHChw8HDjwEWMsGNokVhPT+TyailhAFKzpRdP3Tyb00vvg5LhImOR5FHUDXVaw4mSrOIF6zMoXJWLEhITLAAKtZQyON1FM/ZD/7lzkaQmock349QzJb4JEUJsy6T77+nYCAHTvzmc9PtGtw4MDHwTtYBF1ARKSf/i9cphUrDhxEiIACTpz48CEgsFnbQg89/JJfoX16O43BMEyOipD+Nzo6fvy8/cnX59mwISF96WcNR1ZaWtrQFUuMGbpaQ+ioDulXCRIc7ib8z2ttbR26Yu//YehqDaFBGxZoMHyRu+++e+iKPTqE44SHkBFSwxF1zz33DF2xJUM4fegQMkJqMIxwRkgNhhHOCKnhiBrS67bP3DF0tYaQEVKDYYQzQmo4osrKvnAQzZFx6b1DV2sIGSE1GEY4I6QGwwhnhNRwRN11111f/abBcvWioas1hI6Ku2AMX+xouAvG8PUc4Sd9Gwz/XXp6+tAVW3jr0NUaQkZIDUdUW1vb0BXrHhi6WkPICKnBMMIZITUcUSUlJUNXrCh76GoNISOkhiNqyOY3gqN2fqOvYoTUcERdffXVQ1fs3qeHrtYQMkJqOKIee2wIJwZ7fc3Q1RpCRkgNhhHOCKnBMMIZITUcUS0tLUNX7L37h67WEDqmZws0DL/y8vKhG3V0ym1f/71H0STaRk9qOKIWL1483E046hk9qWFYCYLw1W/6N1/rkRVf1kuWXnVI9UYCoyc1GEY4oyc1HFGPPvro13rfV/WQh9rjHkuMntRwRA3piKNjlBFSwxH1v9wDDhZjd9cwrPSSKw/+4StO6Hz2vv9BRkj/hxxKrzZkD/41fCUjpIYj6owzzvh6b/yqwQVH4aWTwWKE9H/Ql08+N7jHkG+9dWw+6WwoGSeODEfUokXH5jSbQ8kIqeGIWrZs2XA34aj3PxNSBw4u5FvD3QyD4ZAdE8ekk5lMNlnsp4oaalBRyScfN27aaedszsKChdM4lZ1UMIXJLONtpjGN5SwHwIKFMsqQkFjN6mH+iQyGfxmSkAqffAGMZSxppB3Cp0VAw4+fjWz8j1c0NACu5/v8hb8yl7lcwRWATgrJ+PFjx8EcZtNMKy/KS/mb8ggSErOZzQTGk0gCpZQSJsxWtrKYRf8RUvHfdjYyyKCIokP++b142czm/6/d/wuMSzmHb9BDmkIqc5nNdKbjwwcc3NX04AGgiSaqqEYU7DjN6XjCNQAISOjo8Ll/wJLgQNUDpJLKz/k5+ievO3ETIYSKSgtt7Df30mDaSt/EfdgmlHJB+yi2ZoTQXSYeD1YyRsujdsGN/OLDvUzqTuLNaQWc936UxowFfFBgxr21ke4mneztVfxa/z1RPYITCwN4PqvpwcsWthzyOskgndv5GQAuXAQJoqPjxEkbnazgI7az/Rut75FuyZIlxtDAw3TYz4Jx4mQa0ziREzBjpk+K8JH6NrvMbcSbc2kP7kTTIljNSVilGPzRLnRdQ9H8pNtLaQ2Uo+tRkuwT8Ss9RFU/LnMaAaWHcLSHLMdMEtRkeqROEtRk2sQGVKJoqPgybURPPQ41PQZEE/i9sG0r7KyA+noO/g5SAEh0lPJA7jjeaXbyRuANIsoAuu4HZMa6zsY3t4j0vNHsH22nP9IIFXuQX3mfmcJCfATZHf0Yi+wiEOnEJLsIRzuxmlKJql5ULYiuhz5ZIxKCYEKWXESVLgBEwYEomtF1DR0NTfMCAiAyyjyNaZE8pjAZBYX97Gc1a6il9is33qE+C+bTyytf5xLMYPWAgiB8+bI+vf75da+Tfp3b0A73PcPgy54Fc1g9qYiJB8W/8or2PPfwSyKouE2j8KoHSDaVMV4fAzYIaH2UMp1ch4lqXwizIPFx+FVitAROiruMmkCQBYlmPugM45F8pBFHjE2mIBka/TAxSWWfJw63Cd73+rkyP51lN5/JQLWHutceZ6D6I9BV4OA/BgEZizmTcKT9s7/pC9bwSsNUPoq+Qzja+q+fQbBwILSOnFUhNr3zW3QUEM2IM+aiPHwvnU9WsaihnzOks9k7ILBbaiNVS2CV8iIWyc1oeSbdQiut/rUAxNvHM0mfyqIMgYfaG+lXW5BFC26SiQhBInqATv9mPt2Nb6GF59jIczyHhEQRxdwg3so/tafY/m+7yIb/XYcV0l+Z/sr4/P3s9uQRE7iStkiYOQkWZqVMZN4Jq3lpWRGd9emclzqGMwr3UXzVNnrfSaexNgdRnEKPT2dvX5iLC/qZ/+03+WlY4icPXMUyTz3XJGSwoVviuJQok5M6mJupUteXQEcwg4pFpTzIT9m7bDyN0VxW2r9HqlVmQ6gZt+ZmnN3NjmAvteI2nFIy7cEd6LrC8sg7hCKtCIIViykRUZCZLp6ELIhMcMv8XS0gQxrLFHMalTv6cP1wHQ0PXcpZT97H2Mm7Mbn83PXUt8h2RBjVfxntQZWZSTr1vkReI4CIxPWJJYRVkWSrl0XOUfRHRnFympeZo/chySrBgI2/brsek6BzwKeTYBHZ5T94KFBkc+M2wZZgJT8O3MV3lXMJEfqKrWA41h1WSB1YoXsyk2LW4jaFETwWcpxBphTtw3xhFmkf+9AEEybhk90dUUQQNZoH4om1BqjzxFDns9ATTsH98gJqepN4yVNBe2Ab/2w/g9FyAh+3m1jdkUWl2kaCZmIXKxn9so2f3P07MvN3YNrbRYI5xLiYKC5TJpn2KCJR4s1xuPvnIGrgt/Tgj3Rglpzo5lQERNymdEQkfFqYLNnJhwNduOU0LJqVCslHdGYx3vNmUfz8Jt6qy2VNcxYhTcATFXi1WadZrCUiBGlrzyQoBBmINGKT46nxSvRGVJoCbjpCUWRBQBB0rPYQkimKqkjEmjRkUSfNJmGXdJIlB7IgUByj4JY0ujzjkRBw4jrqQ7p06dLhbsJR77CPSdPI5nbTb5B1E/cLv8crBNElK04pia5oDf5w/SfLkhAwkWovYUBpZYp4HLvYSKyUTqNvJaMdp9IU3Ukw0vjJkiVMcjyqFvrkGO4gCxasYjKL46/FPzaOXHMuCSE7IjIW2ckZe7K44JzXCMZZuHBDNgPWIO6whZq4bpyKg6gQJihHmd2UzYbMJl6Y0cgbj59GbWwf/dYQjqiZoElhV3AbsVUqrwceR0WlP1qPIFhAENG1IAgy6MonK0pG10MIyJ+c/PqUivDp70FB5NNdXBCRJRe6riEIIpKq45DjuU36EaOjBTyuPsxHvE+Y8Jeu+6PhmLS1tfXLJyIbrmPSr2uIjl2P2DEpQBuN3Bi9lBRSuJBvYcJE8ieXP5yciA8fAwywS999sDF+GZ18RKGTMj0N0BnFceAPkMVoYDQAueSQqWQCB09OfXqm2ISJPq2P3u4D1K3ezgbaaePg4/VmMIMF/I1LH+2nnXY+5jH+zB95h/eYTxLncTwyMvdxP3Y8tGx5hj+8vpgGPiSdFG7mwk9WiswEJpBIIpdzOi5cCAhouoZT/6QtOvTRxx4q4ev8e9Y/XeEyM5gOyr9+LgsWeqI9fBx9jZ/yweFukhElIyPDuAxzmAbtEkwHHfyZh77wtQwyyCX3P/9SD3zp8taxnn3sO6Q2VFLJ+Vz4H58rYSpw8DLQszzPHvbQTfdnr69iFVlk4cT52d8pKJ9dEvmQD/9rvSyyyObQn+T1e+4nSPCQP2cYBF+3ZxxBd90MyWCGlk++jjTPJ19fxI+fVaz6wteaaPpG9Zo++TIYjqT/mbG7huFx1VUjp0c6WhkhNRxRS5YsGe4mHPWMkBqOqNLS0uFuwlHvmLgLxjBybdu2bXAXOIJO6AwVoyc1fCFBEL7W91ct46uWZfhqRk9qOCoI2/7+le9pGX8RGbufR2dkDZ4/XEZIDf/h6w48GLTpQb/m7uvXadex2jMbu7uGY8ZdaSXD3YQjwgip4Zhx9zEaUmN313BYjtVdzJHE6EkNhhHO6EkN38jXPcFUXl5+hFvyL6V7Xx+yWkPJCKnhm/m6gwoC3WBPPLJtOcYZu7uGI6ps3xtDVqu8+OwhqzWUjJ7UcHi+6v5M4e8jbma+o40R0mPJ3oYv3Q39ug/sPdoNxhnnkbSuDnuOI8Pw+fwcR4IgdAENg7DoRPi36SuOvWWNxDbl6Lqe9EUvGCE9in0+pINFEISt/21SrGNhWSOxTV9awwjp0evzITWbzbrJZDrs5SqKgiwPzpHQSFzWSGxTIBCI6rpu/sIXdV3/r98g6cb3yP3+/PYqLS3VB8NgLWekLmsktgnYqv+XHBqXYAyGEc4IqcEwwhkhNfx/BvNRhSNxWSOxTV/GOHF0FDvUx0wMJV3X+dGtP6amrp7XXnyOwTihdSz7ssdMGD2p4Yj4wwN/5InnX2VdZSPf+d5VxqMmDoMRUsOge+mll7nnt7/HddadOE+7jbdXbuSue3453M06ahkhNQyq9evXc8XV1+Je/HNkdzKi2YZr8R386S9LePLJp4a7eUclI6SGQVNVVcVpi87EcfIPMKcUfPb3kjMO95l3cuMPb2H58uXD2MKjkzHA3jBovnXxtwkpOpb9HxHc/xHSqLnoriS07a8dfIPFydnnnk9PVwdm8xcPrjH8/4yQGgbNpRddQE5ODgDr1q3juRXriLizOC4/nksvuQSAmJiYIx/Q1Tth3qQjW2MIGSE1DJpbbrnlsz+rqspzK3YAUFRUzHnnnTd0DTmGAgrGMalhEA3Fhf2v5d6nh7sFg8oIqWHQPPbYCJmB4fU1w92CQWWE1GAY4Y6RY1KBg79v1E/+DIJgAUDXwwhIIIjouooo2tH1MCB+8l8AYzSMYeQ6SkIqIUtudF1DEm1IopnJ8mxS1DS0aCtj5em4dTdhtRMZGV1XiZezCeIjqPQCIqIoo2kRTKKDiOojjjjSxXTe1z8kQpD1wjY6tVY8Qi8Auh7FCO+haWlpGe4mHPTe/cPdgkE1wkIqISAgiDbGWU9hjJ6JrJkZrWWTSyp+gki6hqzZEDUFiyXM+4KZD4VVAHSJLXjEIOOZhkg1u4WtePVWZNHGXPkUIrrKBuVdInRjlhNJIQVJ03CpMifIJ5Gqu3DgRBV0usV+OsRePlbep48+gnoPRmi/XHl5Oenp6cPdjIMTsiXFDncrBs2whlQQDl4vm2I5jxTiOcM8nlF6Ot1BiRRJp1cNU6P1Uy7upc1cT6/gw6eo9OlBesRubIodm2CjSWylhCmcGJ+OVdI5u7AKqyWEz5+CJ5jH+o5U0mwhTivdwhubT+X9NjNj3AJrev00S030ovGK9iF9ag1mOQZd10hXE8nWcvi+fCsWLYIVK6oosVnbwFZ1LV6bg87wfgA0zYcRYFi8ePHIGEj/w/87pqYRHeKQCtgtOYwSpxODyDnqKZzgTEQSVGojEfIKVtGqr6Ms6wCaJlBVXURNr5V8i86FY6rwhWxU9yXQGbLjkjM4cfQ+PqouAiZywqhKdF1gwO9k/PkrEa56AgD97VspfDadltY0ABaXbeHSjA48LSn8yBKhrSmD16uKcckqb7ZNQUZgXpIZRRPoCgtURHayP9pDg76LEn02VlnmbPU7TImOI95iRhXDvKps5fno34iKGrquoKj9GKEFXVPRVWW4m3HUG5KQSmIMafYpnK4dxy2xhcTJJsTkSur1tXTK3ezrTeCCuWtwZbfz1JJL+N1Pd6BlZFFQ8RTnbc/HfY2T7j+ppAo6Jc+IWHesJDxhJrInRK61GtOmdajjxiJPPXgxXVtTTfiOH2Ep6CewJ4WYzE5SL+9k2+8mMuWC5SjzZpKyayvChY8Ss/MR7tzzBPpFj3Dzyzey/A+nkuTykJnbRGxhIw3rJ9M7EENNTxkHfBKg0xpopNJaj1cRuWbCfuJWnsKT0hMkmGRkSaHOWsMb/mrKxd20B3eiqH1DsZpHlNzcXHy121HVrRR+7y/D3Zyj2hG+6Vsi3TqFf7huJDGcwdpQO0LaNk6ZspbE3BYaKkfz6r5irpm7luSz6wmccCXqL15DuvNkHElzAAiGWrCu+DN09SBc9jgA/p6NOBJmEDrwPOb881FUP6riw/r8nZDgJnTybUSb11K1tYsN448n4ExAaOmhgqncMF3B2fw+xUufRZiQwYE/ZpA2qgH7Yhl9eyvVy2dgtYbI/kE3kcxCLLs2EJ44F122YN38Ho/dcSFWSaUwoYuqniSOK95Db28ciiYRjJip6klhVDSP/OAYkhN7CFvb+e6eHnbKu2kJbkdRew5vlf6bkXbT95IlS0bGgIbXVsM584a7FYfky276PiIhlaU4LnFezuhgESlaLO0xVWQk1TIls4nCGdsZaEwlErLgiPESu7ADrTmEPncS8pQbAVC2PIA89RbC1c8gvbYO8ccPIwoygcDBeZ+t/7wHzWtCXzgFzerEvPJjhKueIIjES8s/YJNtLvHJA2S/1s6C7NdICnSy46UTac9JRj6pn7Zp46nVE5Bkieyt+7mg+XkSRoH3XSsddZl8/+Mizs+C6RmN6LrAxMUrUPqdHNg0EU0TKVqwAUFWCV99J7YVD0NPH7gdBDdYka6ciHn1x+gBgX1vz2bM5VY6fnEWUV8aHgI8FdnFB5F97PW/weHuEo+0kBq+uSENqcOUyyOun3HxiXF0el5gebOTvNheTJJKyX1NSNNv++y9+lPfQ/jO46jrfoM0+3YAojsfQXXGYW49gJKYjtTfieaMxTThWvS3foSw6I//+vzbt4Iso8smPj7xMV70qoz//iqaV/qIN6vkOf0AKJrI+i4nv1iwBldqN2rEhCgraA6NXZESHiu7jFKtnBs8DxBtd7B62QIkUeOFA+lMTQhyfOE+ADJ/b8XUWot4/D3oT32P8EW/wWpJQdMVwk3vYMte/FnbIr+8CVNhGMwmIuOm0nhrmGjXKAqdWZikdG5Z5eUZ8Vl6wlXoeuhQV/PBn3+EhVQQhJFx4qj0qqPuxNGXhXTQjklF0cX33d/nevF4Mmc/j3rLDsS/RlmQJJIwuRpEHXG/DtP/9RnNIyDBZwEF2P9jO2PPWI5eNhpT+XqES/+O9OmL3f3/UTNcVEo0qvCnot+Th4/777iMFbtncdyYLgCeqCxkWoKPSenNbOwuYsvesSQ1eolzeXC4fMSmdRG718/Cd97mrfElrF30CkuO/wXzLe/Qs2sUN7r7GT19J9tXzsRqitD6Uw+53x1A++sVeHfl4Oi8i8ANP6P78qVkLdoBlx0MqfbXK+isnEjiTy46+P99uxh1yct4VrfhUSQs932L2cVp3KDez0ByFef2LKPe/wHGySbDFxmkkEqsLryeidFJdBb8H7ZvLYd9Kjv2nMm4ggOILpXQwrM+62m0FXfBvibETDv6h7cjLPgNmq4gLPsxScnpNK2aQmpPDWowHvsnFYKhFvRTL0be8xjmcVfRe/W9iGeF+Vnpb7kqvIUJVU8RFhUqB9xU9MXQEhRpDSpUeCRusSSR61Bo9Dmp7IshqgukWiPk1/fjsISwyVFO372NnfXtXH37r7hvyp0ktvdijfGihk0UFNSSuLCOtjeLKP/jdEou+pCYR+6i87Lf47v4HXLm70TPyUYAor+9DskNac99H0k8OOop0rMUZdwUtvwpnVafi29vfIwTL7AS8jhI6JzKtsqrecIxmx9334+meQdnk3xDh/qwoxHRcx7jBmHsrsRp1u8zQZmA6dWHyJi7msC2BOpfL6U/bMOZ1Adx1v/YFRSPv4fgJbeAotL8WCr6S9/n78XrWXDhWSRO3UfmvB1sfP84LItjP/uMdsf/0XNTJX85cyy9V9/Lqs1TuSt0Bz9+4xeIp72C8O4ODuwqwqeI9EdFBGCjto4KfR2/3idT75f5oE1mn0dmXIyHrrCZVp+LTp8bgDEJnYTqvchXf8xv9dvY6S/Fcbkb21Qf/gEX/s0JJIxuRNEkdL9EqPZldu4rIu+qA4jJInV/TEXddD9oIuL1TxD5+R3sPOmf7DjxGd64KJdI+mS6Ag5sskLzk5k4i5tx/OlErPdVsSHxJa4vsLI0+T5c1tGHv0mGyRlnnDHcTTho7sThbsGgOuyQzrRdwv85T0c47ReoY85GkFWqt4/jjV2TmF64D8eoVpbccSFPjl1J9LfXEfzZbSjlD2J1joJQhKa2NCKVFo4fvY9cu5WODeNoWjmF3b2J7Lgjl8pTn+D1ye/zzLJTSRlfQ39UwpbUj3iZyNjgXpwbzbicfh59/BLO2Qzv9/Wg6eCQwSklouhhrJhJtans1RuYEh8hK7aXoCISUGQq+2JY1RHPawfy6Y/o+PwRBr69lT+deRVhk4M9j03D7vYh3TyDl19bRIsnlo4tY9l2OUwq2ofe2Itw8RJyT9yCNP02hJPzALDO0VnblIvJFOXEaVtwJMzgnPLJnLYum5TxNXj3ZOGIK8M04Vq29MShzL+fKemtrHX9FkmIOewNe7j+2yMP9M8eQfL/e+utt4a4lf/FgzcOdwsG1WGGVODi6Cl8YF1LJAz933uGFa+eyqO7C6nymtjfkMPet+dgkVSimsjapSdTuXEKvQ+HUbUQ2pgipp6yioH6NMIRM0t+8SipV/aSOvYAx+dXMxB08Mj28azriqM4vptIn4ufrunE+us/8N7C2eQ83ETQ56ClK4mHW9uw6DbqtR1s8/io86kEtD4KpKl0iT0kmBXePWGA667+J5vaMrn+uDVMSW1FEKDSE6G8L8plozpYkKpyYXoXV3/0DPftP5fCOeX0diZiXbuMBr+N5+vc/PzD2ZglhYSSKjrXjWPgunvo2lzMxzPepPHXdrRV9xBcJTMro5HEpB4sbh8RZQBdVyDQhqkwTNjjIPrb6wC4as46ol47NdadWJJ283TsA3x6o8DRZNGiRcPdhINufni4WzCoDuuYNE7IIJk4auRu1KhMdV0u+/vj2eLvJUuMYVV7Cu6eRC4q3UrAb8fuCLBxfzETT16L/I8forTbUS86jpin1pN0bgfa6Y8giRbUCSs5cGqQzJheVB1+0zAGTc3B9Jd3iaZMZ9uHf6O4ZT6b2pJY35rMq30ttCn7mCWdiEW0YtJltrOPKUwjoEfYFl3Hc80LyHens/KJMcSaI3j63fxtdz6NwTAb1Pf4VeZpbOpMorJfZKLipnRtN3XJKeyKmcCEmTvQvQqXT9/EzZkd+DoS8PS72b3sOLa1ZpHu8FKU00Cb30kuINQ2IP7qtwRPWs3Lm2aQYfdz1or7IBKBzl60scWAzivPnctFP4PkU6vo+SgPTRfojt/C3IEisv1TaIxsG5SNPFSWLVs23E04aE3FcLdgUB1WTzrNNB9H2m4mJfTy9oaZbGpP48oLXuPPk328cPNLjI/14pJVEkc3Unh5OVkv3cT5Oxegn1UGIqhBM+YP30XXBLTTf/vZiRZH8nzWd8azuimXsoQAG+d9hPzwL/DXp7HnlI/Y2D+Ls93PMzbWy65+jXgtlsniwYvXhXISYaLIWJgUY6Isxkm+eTrblA95pzmF/Jh+tve6uGnFOBKtOtvZiNOUwtttKg90rGCjWkWtT+b+PfHsfGQlD+g30l5RiNZvwe91sn71TNzZ7SSmd1DTnUJFvx2TpLF2fzGbu10EgjYGNudiefVOstLayHcPUJjaSqDsHITT/4Dw3SfQrA7iiuuxyVFaL/oTP//J97jxtRPY3Z1Mu9fNUiq4lmsPf+sajgmHFdKx+ijcznYc5jBNASsBVcRS0E9BbgPm8SHschSTqGFy+wks+N5nn1MdiWASsUwMAqBFZdS9TxMKd3DgzEfRHr2COLNKS0Bmckorqi6y8+3jaKrK40BPEtt2jyW4K54Mdz+nZ0QY73TSIrVSLTbQGvWjoePQnLw/0MHugTAaGrqu8bJvC9fsDvGiZwdVYi3LBlpIE0ez2DaD2yf0MUM8DhUFVQe7KBHTrdBkjyN1QjVRj4Mxb19JrD1Af1063t5Y8uO7GOUKs7UriVca7Jg+WZtdzalUPj0TqyNARmwvadktOOL+dQlMDHgQTCpmSaWtPYWWgEB1tI/+qExEleiWe8nW0g5n0xiOIYcV0mqxkek3RggrJj7oDHNSVhNdK4pInFjNr39yGXVeN25ThEBLEvZVT1N1xmOo637Dg/OTCO6KR7jgr4jXPEGgO46d17uoPettWrsT+eHd11KW1MX42ACypCKLKhtbs8gZW835v3id7Ng+aveMwW3380wj7PUFSVKTcWhORtmc5Jtd9AmdxOkxqOjUhTfhtmQQSwpO3c1MaSKSbiJWi2GOPR2bBI1eN1l2E6faxtESjKIBU2OcFMT2U7NhMnvWleLvWgtAY0sGWadtZ+xfFQ54LfiiEtcXd3H/X55h7BlrcLp8VLZlUl1TgK4L+PvdqOt+Q+P5D+O/9We8dd1k/LXpzJ29kdIVF/Noaw5XZ9qZntyJJOr0RyR6hKNvvO+IuRxzlA1k+CqHFdJ14WWILx/8je8XQthMEVRFRiq2My+tjQkJ3WTG9OOa0kxwwQ8Y/Z3tRLLGU+j2YpujEK5+Br9nDzE3xTBmYiVj370CgF+dv4zMxE4WlpRjtYTJSmnnpFH7OVBRTKjcwYkXddL5i0Qae5LIsdq4cXSYfLOLMXIybwQ+YLWyk3QthypxN/vEXYw2z2YaZTg1F2NMCcxLVrghLZNvZVhoDaq876vngcYBdvoH6AppuGWZCbEiGekiOa46MkfXEx/bj/qrD3i/IYeJc7agZ2dgGXM5UxO8JFgUdB0q/zaF6++9hiXrZhFWJezmMA57gD11+bCllrrmTDavOziaI+R1YHIdHBFltaSQZA1iN4fRdAFvBMLawOFsmmGxZMmS4W7CQa+tHu4WDKrDCmkfnbyxupRJoxp4Zl4LqakdJBTVE5hzMfPWn8MJG89kxoXvElz4LeyOAoTzHkFPGMeYlFbw+zF98DE7TtvL5uuT+f4/T2fgunsombkVkyNI7vQKks+sxWoLYXf7SCtoZOJ1m6gpn0Dk7GrKE0qZUrifdPvB396JVoEapReXlIpZsJEhu7ALcWioLIhJpTRexCMOEFA1Hmg/wF3NK/lN2zZq9Q569WYcmoMmsQZJEKiL9hNQBBJvjrCwsJpgn5u8RVvwdMZz+62PYT4tHnVzD1vnP8+c4j0sGLWfBm8M3QOx1PojTE/uZkJqC5KkYbWFkEWNaLcbk6ywrSuJaUV76e+NxTLqX0Fc+A6ULlzNhq4YzP5kVqvvH96WHQbXXHPNcDfhoF//c7hbMKgOe8TRTep3eebNf1B8zs3098Zh74zDveYZWFxGwH+AXS8tpPZvMudecCPKVWdi3b+O8e/fRfBne+irT0eWVDq8bsbHaVTsHM+Y0TU89PF8yhL6qPK4uWDSdpJOqGLbkycS1ziA2+0hf+JeGi3z2TRnPDexjoDfQZVnIt+yxdIaTGSnJ4jDKpAZyiBAAmv7BwgLYWZacylwqVj6xrBDshDEg1fowyUkoakasaSQYBEY7Y7l7IIaHi85k/HXvImrpJPgRXeRod1D28cTkDaqaOoodnWmcd2WeBYnuzk+o4XM1Hb+UVCLPX4Aa1IfVWtLyXrpJlKUAd6fbkISNHKdfkJBK1FFJrQ/HrMWRtMViC1CtL3C3n6NM0MJ/JURcqbUMOwOO6RttPLLwG8494Wf85DlWY7bPIkzNvRw0qZb8Tamsq19OnsGLFwQE4TEqQSdWTgA0aSQ/vwPSQf0pTcj/3IBYcXEzspi8pxBoprEt6Zsw2YP8Jd7v8ubLTrXF8az+OqXoCiLb3/wU2448Y8cN/0AwV9pHJfRTF1/PFt6HEx029jrCeMWTSRLFjLsIjZJxyJqnJDZTIEznop6kZ7wAbItpRSSSY3Yyu058TT4VcbGeKg4dwyzPtxFRUs6rb1xLLovBz07mYqa0fSEbPiiJmp9FubH2jCLKgMhG1Pym7H//nfo7/8URBeF+jaiu0KYqneTHTeduLh+DjRnEQofPIv9wAvn8NOEm3j16fNRNJHjRk/nnMhU7uTHh7tZDMeQQRm7u4oVaIrCjcr5vKtWAeBvTyAUtHLpKR/Q25KCdNPBgfJm58HRNNKZOUR+eRP9NZnY4lzUeGI4Ia+G/En7iHw0j4UXvIVy3jwabrIyJ6ueOVkwesoeKt+Yh8MeoLd/DL/86R/52dz/4/fXfZ9cSyc9P5rGDyf0EVFl5IZ0Vnt6SVfdnJLRhSdiZX1XDN1+JzY5SoqWjN9SwDxbLg4ZHMEsFp/wNps2ltE8NYsNMaXc/Nzfiaab2NaaReWpTwCFlHcnMDm+j5kFVQSCNna2ZpEb08f4ybto259H9m+vo/KjmeQW1iL/7hLsLz5AqD6e8b9qQUnMpPdaH6Nm7iDYnsCsgTiCTck0+u3saI1B2b+QO7Wb6KZ7MDbLkFu6dOlwN+GgP90w3C0YVIN6q1oqqfyUn2GxxzBhysu4HH5yxlazbs1MTr7+DQJn3YgjdvJn79ffuAm9yY9g14nOOniTt7n4iv9YpvrglYRbE4l47cTMbiQ8ayGh+/cS8jpIOesAXX1O7r7gb9xc9yijt39I0ztTaOtMprIrBZussLXHzenZrYjoRDWJ0VmNvFUxmfJeMyFVJ84skGrTiDcrzMptYOllCyAi8NP63xDqiqOjMZ0eTwxVvYksmrmBPZVF5KS3kvYrO5HHarCm9sLxo5Gn3oL+5BV0fDSOlAua8C53437o4DM5o7+9Di1owTwxjFqrgagTbEqmtSaH5dVj8DZMIxpt5n7+QIDA117fR+JWtU8H2H/Vmdovel9ra+vImIisq/+om4hsyG/6PpETOU+8hIBJID5vDW+0WLh2TCcZCd0UX7cbYdEf8fv243COAUDZ/vBnN3x/XjDUQvdlrxL/lxLk3gNEHqmhqqKY4mk7MMX62PH+PHolN2uXfguLI4fvv3AKXU8XU3jmOgSbQKAiGfuMAfY/UcrymoOjjVqDVvoiEvNTO9nWk8jUpC7Ki8ZS+8Mszn/rfWZ51x/cbX3mSnpX5rOtYjy+iIXTn23EPO4qAKK7/oZ8oBI1Z/RnbddW3AVVTYjXPIG/ay2CPQ39rr9jTe+mdsVURl29j8CMc3hyNlQNWEntn0BCVON5nmEtaw95PY+0kBr3k35zQx7ST81mNt/mO9RKbVTK3ew27Seg9/HixFSKCqtpbshiwmmrEUQNMUYFk4Bw2eNouoIoHNwTj3xyaxqAv3Ml1ueeIbp4Idb884GDIZZkJ2Y5hkbsPMpoIrs+ZHR8hMkZk8i6+OekLt6P1qrx7OMXs7CknK7ORHKKDsAN43hjfTZbx49jtFbNVc4K5N72/7i/1d+zEfnhF7Dc/SAA6qb7EetqqHxqBtljahFNCsI9V2J3FKA/fgVkJtP1bDxxYxrp2ZuHPX4A2Rbix/84jynxAQZ88fja00hT7DzJU2xm8zdev0ZI/wsjpIcuk0zOZDFjGEOj0M5maxsiElPjLbhNGrmOAK80OpiTpHLFyctRIiYkk4KuCQiijvMKB0pCNvIrH7Hy1dOYWLyXxKn7EZIs6CmpCF0dqDkFn01EBrAzqrGbOHaY8rGpXnR/M7L7X7eB+Zo248yaxlz1AMdLgS8czq6tuAvf6zquE/oRznro4N/95QrqPpjOiqoiThhTyVPbSgip8P/au/vgquo7j+Pv7zn3OY8kN49CnkCiUkAJaBVFa1vRqeJoO+tu69Z2R9FZux23u9PW1bYwOrPb0XF1W7ejtrW1srVj14qV9WFspUVAlEDlQQQCJoEk5BGS3Jv7dO757R83INAAeThwT+D3yjBkzs39ne89yef+7jn3d3+/r1y4i/KKTl5+/1IsJSyc2oLXm2JPVzl/aq0iOSDUW9M4RDdP8wzttE/4uOqQnoAO6cRMZSpLuIla6lCGj91GM10mvGOu5u6iy8n3pmmPeYhaEPLAYAq+Xt/K9zaX8rfTIOSxCHos5kxrprmznOmVbQxGcikO91JU3U6gpgdsiH35H48ZigeZq8hDV91+zPb4nl9jB4vw/c9L2DEfu9fOY19vCYJi28EiNvSYJGxFkc9kTbKJWdQyu9BgVV83l+eU0hW32ZPuYboZpsdKsN9sY5o1lRrKmJOuhVQk834yK/mQDx09lm4L6dKlS90xoOHh5+DBr2a7ijFxVUiP5sHDhVzIVVxJLbXY4qPD7KXZM8ggQxgGFPs81OXCn3pjWKRpkq14xM9nvPMImMJbie3YKk25PY0lpfnU50d4p6uARWWHOJT0cc35O0mnDabN3kX/vnK8gQT7Pq4imgiwb6AQUxRRy0NaCTHLw+sdBpvYjGBQpqrpkXbCqpIB4xCtQ+vI80/DViliqR58ngI8tslV5g1Ms0JUWAWE8BIlykYaWc1qIkRO2/FzW0i18XNtSI/nxUsZZVzNImYxCxMPg2aaNtp5R60j5hXaktsR8RL0lpJKRzEMD4Z4EEwsO4aIgW1b+D15+IxcFDaWHSeRHiTXW4ZPQsTsfhLpAYKeKQgGBVJOlV3JZtZTadTTTStFVFJihxGED9QaUqko5YSpt2u5SE2ngDxyyCFBgh3sYBObaaFlTFdnJ8ptIW1oaKCxsXFC+3fEVx6CFd/LdhVjMmlCOpIwYUop5XI+TSWVGBjkkkuECP0MsJ921vAuvcYgNha2HUHEiyFBbJUAbJRKAzZ/PdGXYEhmFiVbxREEhaKIMCUUcwlz+RSz8OMjRYpmmmmhla1sdeSccqLcFlJ9Tjp+Z2S2wNOlZ/hrpPO5SiqpoILb+RJFdhE+fJmXlwpECXtpoYceBFDYx9w3gJ+5zMVWme2Hgx8gQDfdDDDAOtbzW17EQi+VoGWP60N6Mu3DX42M/BJrNrPx4x/xNoViJa+QJn06SzynVFS45DOw4ezPEeWkSR3SU9nK1myXcE5pb8/+KQAAbzya7Qoc5cCUnpqWsWzZsmyXkPGUS8YQO0SHVHPM8uXLs11CxtMumVrUITqkmuZyOqSa5nI6pJpjXLPs4vMPZrsCR53VV3e1c0zDXaP/2Uk02EH3pJpj5s8fccCMNkG6J9XOTifqKcfS27qE7kk1zeV0SDXH/OAHP8h2CRlLXbK6m0N0SDXHuGbE0d1LTv0zk4gOqeYYV8wUCLD4X7NdgaN0SDXHdHR0ZLuEjJ7Jt47OyeiQaprL6ZBqjpk3b162S8i4oCrbFThKv0+qOea0zm80lvc3J9n8Rqeie1LNMUuXLs12CRkPP5ftChyle1LNMc8888zpn3d3NGNuG+6adPPunozuSTXN5XRINc3ldEg1x7S1tWW7hIzXH8l2BY7SIdUc44rZ6wF2tGS7AkfpkGqOWbLEJWNm//nH2a7AUTqkmuZyOqSa5nI6pJpjnnrqqWyXkPHA32e7AkfpkGqOcc2Io1sXZbsCR+mQao45vBxi1k3CeYxORodU01xOh1TTXE6HVHPMjTfemO0SMq6ak+0KHKVDqjnm9793yWpmj/9TtitwlA6p5pibbnLJVJr3/SjbFThKh1RzzKuvvprtEjLWbMl2BY46Z0IqCLOYle0yNG3MzoqQllBCPfXkkXdkWz5TKKaUfPK5juv4Ol/jV/yCcspZyEIMDKo4dsKqCiqYytQzXb6mndQZnz6lgALyyQeEzHNEelT3S5Cgi64Rb3uEH/Iar3Mbt1FIIXtoYhrVTDdn8XF6B7dyM9vZwa/kRZ5SP8HEZD9tNHAJd3EPN3A9RRTRQQfzaeDL3D7ifoIECRMe82OOE6eb7jHfb7JRSmW7hIxJtKzhaDgeUi9e6qlnEVdRQgkAueQSIQIIaSzaaMOQAIW+WvoSO/GaBaTSB49qxQDs4e8FU3IoUrmECGIaISx7kFyZQlxFsUgSI8EbwQ9Za3bRGTzA9BlXsrRvNr+s6yGndAG70j3UxS9k5y0NDKxqZWFHMSsuVaRejrCg8D5WVcdIbt1OW/daSnqn8rD6d9LY5BAgSgybFKAwMfmYj497xAKc+I9TMAlTRJDgkWMRJYpCYaPY5tnPH6z/ZYABZ34BWfT000+7Y2jgS38+q4YGysme/UQ8p3xqFIQKKriZJdRRR4oUO9nJBm8TUX+AgfQBYqk+vGYONebFpCRJP930JfYw07eIptR6LvZ8js2pN7HSg+T4KwmZxfTGd5K2YxQEZlDHHGxRpEiyX+0gZQ9R5K2hzKhh99UhBi4uRgrDSCyJROOk/7IBPt5Djr+GaNMGZChCRegy7q+s5w8HvGywt3Co2CIW6sc0C6kJfhrvwvmUVuezRzx0HdpG+tXfE9i2j2+XX088bfCT3tXEUn1YdhTbHkLEJOAtp86zgKbUehKpTkS8KJVCxMTnCZOyMjOpK9Lk+auJJg8g4sFK9yISoJAwd/u/hS/eTx45dNDBOjbQyPukSJ3yl6eUdcw4vPnz56uJrrZ9eGjfqXrFkX5ORE5fb3p4qN9oJyI71dKHLuttRaRRKTXiAq8T7ElNHjeepNneyUpWspe9ZHoWKPUt4AqpJxS4gG3SS7UxhXvqezANHwmrmoc+msGgDHJH4S2sj3ZxX9mtrDrYyWWhcgImNDOX0oCHA3GLBUUGzVGDlK0oThRSlRtk17c+x6HcIEOv/QyeWIEaiCASwCYNKoHPU0bU+ggwECNEZ2wLb3d+itXWGg7FtkM088ekJIdm2cHsDzt5J/YKSiVQU4qQW75I4ut3kPj1br5R/RozN1/KqrYQb1trma7msDn5Kn4zH1tsAp5CkqkuFga+zIfSSFiqWFZbwLN7Q6xNv4lH/Cz2f5b1ng8JqTx2R1/DNIIcsrtYJ9tZIytQKk4lNSwyP8d9cj/fSX+bFrVjYr8e7awwoZD+Q+A7zAknITjIwt4buMRSPHTlFj7YV8M18xr53fokB5MeHryojRk3/Bbj3p8DYDU+zoIfJehsryCe3Mu9gRgX/cs6lpdOZdM3Y1z6tTe497v3MJBS3D2zn5ribgaGQrT2T8EGGpdczA/Pe5yexyp5u7OEffbfUVVmsnFgkIhEuTqvnG0DcZr8u2iQWbTYB9mT3sj2dDsAM3NuxMYmpHKpM4u4oEC4rKSPO3ZMpchTw9Uyg/4XbYbe3M7mJxZT8N6zXNK1j7+55S88+cIXubaqmQ86b6ZtKIACDsQq+Z2Rz4CK8p3yy6jKGeKiiv08UiFs3H8N1fn9XHP/r0ksvh/fe8/Q/3wNLU21vLT7fKb4LHoPfIEeaeMa3zxm5Ck+sv7IE51Pcmv685knHe2cNqGQftqazWAiytzz+ohaJfQmTGYsfhfzLZvwF1opbGygdciPz5dEfJ/cz9y0hZ7OK9nVVU5PPIApCu8TFoXhPl7e28ALD9zDpkg/d1b5WNdVxI935vGx7OdyXx4Ry6ay8SA/q7ub+tB7DFlJfIbBwpJ+vEYBITOXmfkRpoYCdMTmEDAVuw7FMcSgSpUxYPRgYzPEAJZhcWm4EK8oftE0hQLPeVwsdWyP9VNbV0XwzkuYu3Yz//HiF1FK+MxgPrOmHKSpt5SWSJA/9SQZkCGGJEJfYg8pX4ymwSvpTeSzc+ACCr1pBi2T2vxD4A8Q8JeRKK+h4FNvUzqQS92B87BsgymqgITEmZGnmJkfYfeBMCYG5ZTTjksm9xqFV155JdslZPznN7JdgaMmdE5qYLCAK7jP8wBNso9H5REKfdUM2t3kGMX0JJuIJ9tBDAQvhuFjgW8JFd4Qfakkm9Q7BM0pdEU3Mj1nMSGVS6e00Bl9HxEvef5q4lY/aTuGrWIcvqB0fmgxZTXziC6qp2ooRE1niLKhPDxmgJld+fzb1W+xLxznS2vCdOQMkpv00pLThc/IR1lDJI0Ul3fWsa58Lxsb4CcvfZbe4BCWCXFPmoMFadbn7qBwQzcbm1eQtAZJp/sxjBwMw4dp+AFIpLpA2SgUkEaOfiYClEpmtikbET8iHpSy8Jh5BL1FJNORTDvWQQzxcI/vWyxKXso6+y1+o56ng5OvUua2c9L29vbTt/zhWM4luw9BSeHE2zmDTnZOOuELR4ddxmXcxI1YWOSQQ4QIUaJ00UUvfXzABwAYhDAMP0pZpNUgJ7o6WksttdQAUEUVJibwyZXiNGn2sIdW9rGb3XTRxWxjLivUc6xUKwkaOWzK3cVjg8v4s+9dclUO1yYX4sHDs4HfUGGXstL/BrOiNSTsGDmE+AbfpIgicsllIVdQTDFhwoQIESOGjY2JSRNNgNBNN1vZOtpDBIAHD1cOv09bTTUGxpHH1E03P+dZ4sRH1ZbbQqovHI3fabxw9IkNw19HK6OMIEFqqOE6Pv/JDTan1EMPf2YNAH30jeotioN2L8tZzhu8ScSOIAPCKl4gkohQSCFLuInN/IUt8S3kkUd/MnP19VquxY//yL766KOV1hH3ESRIGWUA1FF37OMapfd4nwgRenmZQQbHfH/t3HJaBzN00glAM82sZvXp3BUA+4e/DlMo+skEsZdenuUXR247vB3gj/xx1PuIEaOZZoAj/2tnzmhmf1Dz7jwDlZw5Z8WwQM0d7rrLJdOW3HJVtitwlF5VTXPMaV9RjZOfKx/pZc+iFdVA96SagxoaGrJdQsZXHsp2BY7SIdUcs2nTpmyXkPHRyBf9JisdUk1zOR1SzTEVFRXZLiEjXJDtChylQ6o5pr29PdslZLzxaLYrcJQOqeaYZcuWZbuEjKdcMobYITqkmmOWL1+e7RIynnbJ1KIO0SHVzkoiMuK/yUiHVNNcTodUc8xEP4EzUUqpzIik5x888v3x/yYjPSxQy65sLVM42v264CNtuifVHDN//ogfhzzzbn842xU4Svekmjucosc68iFzJtazyaafZto51UtfFy1ErEN6NtnRMuE/riOfxTxFOyf8uXHu/0xfeT3V/kZ7HM4Ex6ZP0c6846dPEZFuoMWBpsNAjwPtuLUtN9ZUrZQqGemGk4ZUOzeJyMYTzbdzNrTlxppORl840jSX0yHVNJfTIdVG4uQ8KG5sy401nZA+J9U0l9M9qaa5nA6pprmcDqmmuZwOqYaIXCEiz4nIkyLy/aO2PyQia0WkX0QGROSSUbY3Q0Q2H7dtTG2JyHki8oKI/LeI3OtkPRNo56+O03jbGgs9LFADmALcq5QaFJE3AURkEVCplFooIrcBVUqpzSdtJXO/cuBOIHrUtvG0dTfwX0qpdSLyfyKyzYl6xvu4hh1znCbY1qjpnlRDKbUKiIjIA8CK4c3Xw5HFc9JAapRtHVBKfReIHLV5PG2VA/uGvz8I3OZQPeN6XMNtHX+cxt3WWOiQnsNE5PvDLylvBn4KvKuU+uXwzX7AJyIG8FVg1Sjbum6Em8fU1rBWYOrw90VAbBxtjGQ8tQAgInkce5zG3dZY6PdJNUTk58D5ZAbnp5VSd4jIbDK9RBR4Rin1qzG2+bpS6vrh78fc1vDL1MeAQWAj8K4T9UzkcR1/nIBHJ1LTqPerQ6pp7qZf7mqay+mQaprL6ZBqmsvpkGqay+mQaprL6ZBqmsvpkGqay+mQaprL/T9Ry3it9Kgj5AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for mpId, mp in enumerate(mps):\n", + " fig, axs = plt.subplots(ng,2, figsize=(2*scale, 1*ng*scale*420/400), **args)\n", + " for gene, (ax1, ax2) in zip(control.get_gene_names(), axs):\n", + " ax1.axis(\"off\")\n", + "# vmin, vmax = common.Projector.get_shared_gfp_range(data[gene], [20,98])\n", + " \n", + " proj = common.Projector(data[gene][mpId], mask_on=True, box_size=bbox, force_fit=True)\n", + " proj.set_projection_mode(ax=\"z\", mode=mode)\n", + " proj.compute()\n", + " pz = proj.projs[\"gfp\"].copy()\n", + " contourz = proj.get_proj_contours()\n", + " proj.set_projection_mode(ax=\"y\", mode=mode)\n", + " proj.compute()\n", + " py = proj.projs[\"gfp\"].copy()\n", + " contoury = proj.get_proj_contours()\n", + " im = np.concatenate([py[yyi:yyf, :], pz[yzi:yzf, :]], axis=0)\n", + " view = ax1.imshow(im, cmap=\"inferno\", origin=\"lower\")\n", + " view.set_clim(0, contrast[gene])\n", + " for alias_cont, alias_color in zip([\"nuc\", \"mem\"], [\"cyan\", \"magenta\"]):\n", + " if gene in [\"LMNB1\", \"NUP153\", \"HIST1H2BJ\", \"SEC61B\", \"ATP2A2\"] and alias_cont==\"nuc\":\n", + " continue\n", + " [ax1.plot(c[:,1], c[:,0]-yyi, lw=0.5, color=alias_color) for c in contoury[alias_cont]]\n", + " [ax1.plot(c[:,1], c[:,0]+(yyf-yyi)-yzi, lw=0.5, color=alias_color) for c in contourz[alias_cont]]\n", + " \n", + " common.make_lda_histogram(df=pca_lda[gene][\"axes\"], ax=ax2, verbose=False)\n", + " if gene != control.get_gene_names()[0]:\n", + " ax2.arrow(mp, 1.7, 0, dy=0.2, width=0.1, head_length=0.1, head_width=0.5)\n", + " plt.savefig(f\"MovieEdgesLDS_mp{mpId}.png\", dpi=150)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4157f7c5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/tools/common.py b/notebooks/tools/common.py index 3624f99..099450d 100644 --- a/notebooks/tools/common.py +++ b/notebooks/tools/common.py @@ -939,6 +939,12 @@ def sort_pcs(axes, groups, pca=None): pca.components_[pcid] *= -1 return axes, pca +def get_managers_from_staging_path(path): + config = general.load_config_file(path) + control = controller.Controller(config) + device = io.LocalStagingIO(control) + return control, device + def get_managers_from_step_path(path): with open(Path(path)/"parameters.yaml", "r") as f: config = yaml.load(f, Loader=yaml.FullLoader) @@ -946,14 +952,10 @@ def get_managers_from_step_path(path): device = io.LocalStagingIO(control) return control, device -def setup_cvapipe_for_matched_dataset(config, dataset, step_to_use="preprocessing"): +def setup_cvapipe_for_matched_dataset(dataset, step_to_use="preprocessing"): dsmanagers = {} - for pheno, path in dataset.items(): - step_path = Path(path) / step_to_use - control, device = get_managers_from_step_path(step_path) -# config["project"]["local_staging"] = path -# control = controller.Controller(config) -# device = io.LocalStagingIO(control) + for pheno, staging in dataset.items(): + control, device = get_managers_from_staging_path(staging) dsmanagers[pheno] = {"control": control, "device": device} return dsmanagers diff --git a/setup.py b/setup.py index e1b26a8..8a0512d 100644 --- a/setup.py +++ b/setup.py @@ -13,65 +13,33 @@ ] test_requirements = [ - "black>=19.10b0", - "codecov>=2.1.4", - "flake8>=3.8.3", - "flake8-debugger>=3.2.1", - "pytest>=5.4.3", - "pytest-cov>=2.9.0", - "pytest-raises>=0.11", + "black", + "flake8", + "flake8-debugger", + "pytest", + "pytest-cov", + "pytest-raises", ] dev_requirements = [ *setup_requirements, *test_requirements, - "bumpversion>=0.6.0", - "coverage>=5.1", - "ipython>=7.15.0", - "m2r>=0.2.1", - "pytest-runner>=5.2", - "Sphinx>=2.0.0b1,<3", - "sphinx_rtd_theme>=0.4.3", - "tox>=3.15.2", - "twine>=3.1.1", - "wheel>=0.34.2", -] - -step_workflow_requirements = [ - "bokeh>=2.0.2", - "dask[bag]>=2.18.1", - "dask_jobqueue>=0.7.0", - "datastep>=0.1.9", - "distributed>=2.18.0", - "docutils", - "fire", - "prefect==0.14.15", - "python-dateutil", - "aics_dask_utils", + "bump2version", + "coverage", + "ipython", + "m2r2", + "pytest-runner", + "sphinx", + "furo", + "tox", + "twine", + "wheel", ] requirements = [ - *step_workflow_requirements, - # project requires - "numpy==1.23", - "pandas==1.5.3", - "Pillow", - "matplotlib", - "seaborn", - "tqdm", - "scipy", - "scikit-image", - "aicsimageio", - "imgkit==1.0.2", - "xvfbwrapper==0.2.9", - "pyshtools==4.10", - "aicsshparam>=0.1.1", - "aicscytoparam==0.1.6", - "vtk==9.0.1", - "quilt3", - "ffmpeg", - "jupyterlab", - "ipywidgets" + "jupyter", + "aicsshparam", + "aicscytoparam", ] extra_requirements = { @@ -81,22 +49,20 @@ "all": [ *requirements, *dev_requirements, - ], + ] } setup( - author="Allen Institute for Cell Science", - author_email="ritvik.vasan@alleninstitute.org", + author="Matheus Viana", + author_email="matheus.viana@alleninstitute.org", classifiers=[ - "Development Status :: 2 - Pre-Alpha", - "Intended Audience :: Developers", + "Development Status :: 5 - Production/Stable", + "Intended Audience :: Science/Research", "License :: Free for non-commercial use", "Natural Language :: English", - "Programming Language :: Python :: 3.7", - "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3 :: Only" ], - description="Analysis of data produced by cvapipe for the variance paper", - entry_points={"console_scripts": ["cvapipe_analysis=cvapipe_analysis.bin.cli:cli"]}, + description="Analysis pipeline usinf in Integrated intracellular organization and its variations in human iPS cells", install_requires=requirements, license="Allen Institute Software License", long_description=readme, @@ -105,7 +71,7 @@ keywords="cvapipe_analysis", name="cvapipe_analysis", packages=find_packages(exclude=["tests", "*.tests", "*.tests.*"]), - python_requires=">=3.7", + python_requires=">=3.9", setup_requires=setup_requirements, test_suite="cvapipe_analysis/tests", tests_require=test_requirements, @@ -115,4 +81,4 @@ # Details in CONTRIBUTING.rst version="0.1.4", zip_safe=False, -) +) \ No newline at end of file diff --git a/tox.ini b/tox.ini index cca3492..2c41c8a 100644 --- a/tox.ini +++ b/tox.ini @@ -1,6 +1,6 @@ [tox] skipsdist = True -envlist = py37, py38, lint +envlist = py39, py310, py311, lint [testenv:lint] deps =