예제 #1
0
    def __init__(self,
                 *,
                 mask=None,
                 resample=False,
                 memory_limit=None,
                 **kwargs):
        if mask is not None:
            mask = get_masker(mask)
        self.masker = mask
        self.resample = resample
        self.memory_limit = memory_limit

        # defaults for resampling images (nilearn's defaults do not work well)
        self._resample_kwargs = {"clip": True, "interpolation": "linear"}

        # Identify any kwargs
        resample_kwargs = {
            k: v
            for k, v in kwargs.items() if k.startswith("resample__")
        }

        # Flag any extraneous kwargs
        other_kwargs = dict(set(kwargs.items()) - set(resample_kwargs.items()))
        if other_kwargs:
            LGR.warn(
                f"Unused keyword arguments found: {tuple(other_kwargs.items())}"
            )

        # Update the default resampling parameters
        resample_kwargs = {
            k.split("resample__")[1]: v
            for k, v in resample_kwargs.items()
        }
        self._resample_kwargs.update(resample_kwargs)
예제 #2
0
파일: base.py 프로젝트: neurostuff/NiMARE
    def __init__(self, kernel_transformer, *, mask=None, **kwargs):
        if mask is not None:
            mask = get_masker(mask)
        self.masker = mask

        # Identify any kwargs
        kernel_args = {
            k: v
            for k, v in kwargs.items() if k.startswith("kernel__")
        }

        # Flag any extraneous kwargs
        other_kwargs = dict(set(kwargs.items()) - set(kernel_args.items()))
        if other_kwargs:
            LGR.warn(
                f"Unused keyword arguments found: {tuple(other_kwargs.items())}"
            )

        # Get kernel transformer
        kernel_args = {
            k.split("kernel__")[1]: v
            for k, v in kernel_args.items()
        }
        kernel_transformer = _check_type(kernel_transformer, KernelTransformer,
                                         **kernel_args)
        self.kernel_transformer = kernel_transformer
예제 #3
0
    def masker(self, mask):
        mask = get_masker(mask)
        if hasattr(self, "masker") and not np.array_equal(
                self.masker.mask_img.affine, mask.mask_img.affine):
            # This message does not have an associated effect,
            # since matrix indices are calculated as necessary
            LGR.warning(
                "New masker does not match old masker. Space is assumed to be the same."
            )

        self.__masker = mask
예제 #4
0
def test_kernel_peaks(testdata_cbma, tmp_path_factory, kern, res, param,
                      return_type, kwargs):
    """Peak/COMs of kernel maps should match the foci fed in (assuming focus isn't masked out).

    Notes
    -----
    Remember that dataframe --> dataset won't work.
    Only testing dataset --> dataset with ALEKernel because it takes a while.
    Test on multiple template resolutions.
    """
    tmpdir = tmp_path_factory.mktemp("test_kernel_peaks")
    testdata_cbma.update_path(tmpdir)

    id_ = "pain_03.nidm-1"

    # Ignoring resolution until we support 0.8.1
    # template = load_mni152_brain_mask(resolution=res)
    template = load_mni152_brain_mask()
    masker = get_masker(template)

    xyz = testdata_cbma.coordinates.loc[testdata_cbma.coordinates["id"] == id_,
                                        ["x", "y", "z"]]
    ijk = mm2vox(xyz, masker.mask_img.affine)
    ijk = np.squeeze(ijk.astype(int))

    if param == "dataframe":
        input_ = testdata_cbma.coordinates.copy()
    elif param == "dataset":
        input_ = testdata_cbma.copy()

    kern_instance = kern(**kwargs)
    output = kern_instance.transform(input_, masker, return_type=return_type)

    if return_type == "image":
        kern_data = output[0].get_fdata()
    elif return_type == "array":
        kern_data = np.squeeze(
            masker.inverse_transform(output[:1, :]).get_fdata())
    else:
        f = output.images.loc[output.images["id"] == id_,
                              kern_instance.image_type].values[0]
        kern_data = nib.load(f).get_fdata()

    if isinstance(kern_instance, kernel.ALEKernel):
        loc_idx = np.array(np.where(kern_data == np.max(kern_data))).T
    elif isinstance(kern_instance, (kernel.MKDAKernel, kernel.KDAKernel)):
        loc_idx = np.array(center_of_mass(kern_data)).astype(int).T
    else:
        raise Exception(f"A {type(kern_instance)}? Why?")

    loc_ijk = np.squeeze(loc_idx)

    assert np.array_equal(ijk, loc_ijk)
예제 #5
0
    def __init__(self, *args, **kwargs):
        mask = kwargs.get("mask")
        if mask is not None:
            mask = get_masker(mask)
        self.masker = mask

        self.resample = kwargs.get("resample", False)
        self.memory_limit = kwargs.get("memory_limit", None)

        # defaults for resampling images (nilearn's defaults do not work well)
        self._resample_kwargs = {"clip": True, "interpolation": "linear"}
        self._resample_kwargs.update(
            {k.split("resample__")[1]: v for k, v in kwargs.items() if k.startswith("resample__")}
        )
예제 #6
0
    def __init__(
        self,
        masker,
        kernel_transformer=MKDAKernel,
        feature_group=None,
        features=None,
        **kwargs,
    ):
        self.masker = get_masker(masker)

        # Get kernel transformer
        kernel_args = {
            k.split("kernel__")[1]: v
            for k, v in kwargs.items() if k.startswith("kernel__")
        }
        kernel_transformer = _check_type(kernel_transformer, KernelTransformer,
                                         **kernel_args)
        self.kernel_transformer = kernel_transformer

        self.feature_group = feature_group
        self.features = features
        self.frequency_threshold = 0
예제 #7
0
 def __init__(self, df, img):
     self.coordinates = df
     self.masker = get_masker(img)
예제 #8
0
def transform_images(images_df,
                     target,
                     masker,
                     metadata_df=None,
                     out_dir=None,
                     overwrite=False):
    """Generate images of a given type from other image types and write out to files.

    .. versionchanged:: 0.0.9

        * [ENH] Add overwrite option to transform_images

    .. versionadded:: 0.0.4

    Parameters
    ----------
    images_df : :class:`pandas.DataFrame`
        DataFrame with paths to images for studies in Dataset.
    target : {'z', 'p', 'beta', 'varcope'}
        Target data type.
    masker : :class:`~nilearn.input_data.NiftiMasker` or similar
        Masker used to define orientation and resolution of images.
        Specific voxels defined in mask will not be used, and a new masker
        with _all_ voxels in acquisition matrix selected will be created.
    metadata_df : :class:`pandas.DataFrame` or :obj:`None`, optional
        DataFrame with metadata. Rows in this DataFrame must match those in
        ``images_df``, including the ``'id'`` column.
    out_dir : :obj:`str` or :obj:`None`, optional
        Path to output directory. If None, use folder containing first image
        for each study in ``images_df``.
    overwrite : :obj:`bool`, optional
        Whether to overwrite existing files or not. Default is False.

    Returns
    -------
    images_df : :class:`pandas.DataFrame`
        DataFrame with paths to new images added.
    """
    images_df = images_df.copy()

    valid_targets = {"z", "p", "beta", "varcope"}
    if target not in valid_targets:
        raise ValueError(
            f"Target type {target} not supported. Must be one of: {', '.join(valid_targets)}"
        )

    mask_img = masker.mask_img
    new_mask = np.ones(mask_img.shape, int)
    new_mask = nib.Nifti1Image(new_mask,
                               mask_img.affine,
                               header=mask_img.header)
    new_masker = get_masker(new_mask)
    res = masker.mask_img.header.get_zooms()
    res = "x".join([str(r) for r in res])
    if target not in images_df.columns:
        target_ids = images_df["id"].values
    else:
        target_ids = images_df.loc[images_df[target].isnull(), "id"]

    for id_ in target_ids:
        row = images_df.loc[images_df["id"] == id_].iloc[0]

        # Determine output filename, if file can be generated
        if out_dir is None:
            options = [
                r for r in row.values if isinstance(r, str) and op.isfile(r)
            ]
            id_out_dir = op.dirname(options[0])
        else:
            id_out_dir = out_dir
        new_file = op.join(id_out_dir, f"{id_}_{res}_{target}.nii.gz")

        # Grab columns with actual values
        available_data = row[~row.isnull()].to_dict()
        if metadata_df is not None:
            metadata_row = metadata_df.loc[metadata_df["id"] == id_].iloc[0]
            metadata = metadata_row[~metadata_row.isnull()].to_dict()
            for k, v in metadata.items():
                if k not in available_data.keys():
                    available_data[k] = v

        # Get converted data
        img = resolve_transforms(target, available_data, new_masker)
        if img is not None:
            if overwrite or not op.isfile(new_file):
                img.to_filename(new_file)
            else:
                LGR.debug("Image already exists. Not overwriting.")

            images_df.loc[images_df["id"] == id_, target] = new_file
        else:
            images_df.loc[images_df["id"] == id_, target] = None
    return images_df
예제 #9
0
 def __init__(self, estimator, mask, maps=None):
     self.estimator = copy.deepcopy(estimator)
     self.masker = get_masker(mask)
     self.maps = maps or {}