# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.4.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.


import collections

from sys import version_info as _version_info
if _version_info < (3, 7, 0):
    raise RuntimeError("Python 3.7 or later required")

from . import _ITKCommonPython


from . import _ITKClassifiersPython



from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
    from . import _itkBayesianClassifierImageFilterPython
else:
    import _itkBayesianClassifierImageFilterPython

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


if _swig_python_version_info[0:2] >= (3, 3):
    import collections.abc
else:
    import collections

import itk.ITKCommonBasePython
import itk.itkMatrixPython
import itk.itkVectorPython
import itk.itkFixedArrayPython
import itk.pyBasePython
import itk.vnl_vector_refPython
import itk.stdcomplexPython
import itk.vnl_vectorPython
import itk.vnl_matrixPython
import itk.itkCovariantVectorPython
import itk.itkPointPython
import itk.vnl_matrix_fixedPython
import itk.itkImageToImageFilterAPython
import itk.itkImageToImageFilterCommonPython
import itk.itkImageRegionPython
import itk.itkSizePython
import itk.itkIndexPython
import itk.itkOffsetPython
import itk.itkVectorImagePython
import itk.itkVariableLengthVectorPython
import itk.itkImagePython
import itk.itkRGBAPixelPython
import itk.itkRGBPixelPython
import itk.itkSymmetricSecondRankTensorPython
import itk.itkImageSourcePython
import itk.itkPhasedArray3DSpecialCoordinatesImagePython
import itk.itkImageSourceCommonPython
import itk.itkImageToImageFilterBPython

def itkBayesianClassifierImageFilterVIF2SSFF_New():
    return itkBayesianClassifierImageFilterVIF2SSFF.New()

class itkBayesianClassifierImageFilterVIF2SSFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVIF2ISS2):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVIF2SSFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVIF2SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVIF2SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF2IF2 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF2IF2_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF2 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVIF2SSFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVIF2SSFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVIF2SSFF

        Create a new object of the class itkBayesianClassifierImageFilterVIF2SSFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVIF2SSFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVIF2SSFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVIF2SSFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVIF2SSFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2SSFF_swigregister(itkBayesianClassifierImageFilterVIF2SSFF)

def itkBayesianClassifierImageFilterVIF2UCFF_New():
    return itkBayesianClassifierImageFilterVIF2UCFF.New()

class itkBayesianClassifierImageFilterVIF2UCFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVIF2IUC2):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVIF2UCFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVIF2UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVIF2UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF2IF2 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF2IF2_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF2 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVIF2UCFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVIF2UCFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVIF2UCFF

        Create a new object of the class itkBayesianClassifierImageFilterVIF2UCFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVIF2UCFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVIF2UCFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVIF2UCFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVIF2UCFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF2UCFF_swigregister(itkBayesianClassifierImageFilterVIF2UCFF)

def itkBayesianClassifierImageFilterVIF3SSFF_New():
    return itkBayesianClassifierImageFilterVIF3SSFF.New()

class itkBayesianClassifierImageFilterVIF3SSFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVIF3ISS3):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVIF3SSFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVIF3SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVIF3SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF3IF3 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF3IF3_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF3 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVIF3SSFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVIF3SSFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVIF3SSFF

        Create a new object of the class itkBayesianClassifierImageFilterVIF3SSFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVIF3SSFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVIF3SSFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVIF3SSFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVIF3SSFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3SSFF_swigregister(itkBayesianClassifierImageFilterVIF3SSFF)

def itkBayesianClassifierImageFilterVIF3UCFF_New():
    return itkBayesianClassifierImageFilterVIF3UCFF.New()

class itkBayesianClassifierImageFilterVIF3UCFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVIF3IUC3):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVIF3UCFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVIF3UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVIF3UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF3IF3 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF3IF3_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF3 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVIF3UCFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVIF3UCFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVIF3UCFF

        Create a new object of the class itkBayesianClassifierImageFilterVIF3UCFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVIF3UCFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVIF3UCFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVIF3UCFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVIF3UCFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIF3UCFF_swigregister(itkBayesianClassifierImageFilterVIF3UCFF)

def itkBayesianClassifierImageFilterVISS2SSFF_New():
    return itkBayesianClassifierImageFilterVISS2SSFF.New()

class itkBayesianClassifierImageFilterVISS2SSFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVISS2ISS2):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVISS2SSFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVISS2SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVISS2SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF2IF2 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF2IF2_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF2 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVISS2SSFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVISS2SSFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVISS2SSFF

        Create a new object of the class itkBayesianClassifierImageFilterVISS2SSFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVISS2SSFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVISS2SSFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVISS2SSFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVISS2SSFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2SSFF_swigregister(itkBayesianClassifierImageFilterVISS2SSFF)

def itkBayesianClassifierImageFilterVISS2UCFF_New():
    return itkBayesianClassifierImageFilterVISS2UCFF.New()

class itkBayesianClassifierImageFilterVISS2UCFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVISS2IUC2):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVISS2UCFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVISS2UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVISS2UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF2IF2 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF2IF2_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF2 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVISS2UCFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVISS2UCFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVISS2UCFF

        Create a new object of the class itkBayesianClassifierImageFilterVISS2UCFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVISS2UCFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVISS2UCFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVISS2UCFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVISS2UCFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS2UCFF_swigregister(itkBayesianClassifierImageFilterVISS2UCFF)

def itkBayesianClassifierImageFilterVISS3SSFF_New():
    return itkBayesianClassifierImageFilterVISS3SSFF.New()

class itkBayesianClassifierImageFilterVISS3SSFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVISS3ISS3):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVISS3SSFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVISS3SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVISS3SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF3IF3 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF3IF3_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF3 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVISS3SSFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVISS3SSFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVISS3SSFF

        Create a new object of the class itkBayesianClassifierImageFilterVISS3SSFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVISS3SSFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVISS3SSFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVISS3SSFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVISS3SSFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3SSFF_swigregister(itkBayesianClassifierImageFilterVISS3SSFF)

def itkBayesianClassifierImageFilterVISS3UCFF_New():
    return itkBayesianClassifierImageFilterVISS3UCFF.New()

class itkBayesianClassifierImageFilterVISS3UCFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVISS3IUC3):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVISS3UCFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVISS3UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVISS3UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF3IF3 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF3IF3_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF3 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVISS3UCFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVISS3UCFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVISS3UCFF

        Create a new object of the class itkBayesianClassifierImageFilterVISS3UCFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVISS3UCFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVISS3UCFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVISS3UCFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVISS3UCFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVISS3UCFF_swigregister(itkBayesianClassifierImageFilterVISS3UCFF)

def itkBayesianClassifierImageFilterVIUC2SSFF_New():
    return itkBayesianClassifierImageFilterVIUC2SSFF.New()

class itkBayesianClassifierImageFilterVIUC2SSFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVIUC2ISS2):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVIUC2SSFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVIUC2SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVIUC2SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF2IF2 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF2IF2_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF2 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVIUC2SSFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVIUC2SSFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVIUC2SSFF

        Create a new object of the class itkBayesianClassifierImageFilterVIUC2SSFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVIUC2SSFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVIUC2SSFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVIUC2SSFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVIUC2SSFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2SSFF_swigregister(itkBayesianClassifierImageFilterVIUC2SSFF)

def itkBayesianClassifierImageFilterVIUC2UCFF_New():
    return itkBayesianClassifierImageFilterVIUC2UCFF.New()

class itkBayesianClassifierImageFilterVIUC2UCFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVIUC2IUC2):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVIUC2UCFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVIUC2UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVIUC2UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF2IF2 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF2IF2_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF2 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVIUC2UCFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVIUC2UCFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVIUC2UCFF

        Create a new object of the class itkBayesianClassifierImageFilterVIUC2UCFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVIUC2UCFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVIUC2UCFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVIUC2UCFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVIUC2UCFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC2UCFF_swigregister(itkBayesianClassifierImageFilterVIUC2UCFF)

def itkBayesianClassifierImageFilterVIUC3SSFF_New():
    return itkBayesianClassifierImageFilterVIUC3SSFF.New()

class itkBayesianClassifierImageFilterVIUC3SSFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVIUC3ISS3):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVIUC3SSFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVIUC3SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVIUC3SSFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF3IF3 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF3IF3_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF3 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVIUC3SSFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVIUC3SSFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVIUC3SSFF

        Create a new object of the class itkBayesianClassifierImageFilterVIUC3SSFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVIUC3SSFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVIUC3SSFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVIUC3SSFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVIUC3SSFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3SSFF_swigregister(itkBayesianClassifierImageFilterVIUC3SSFF)

def itkBayesianClassifierImageFilterVIUC3UCFF_New():
    return itkBayesianClassifierImageFilterVIUC3UCFF.New()

class itkBayesianClassifierImageFilterVIUC3UCFF(itk.itkImageToImageFilterBPython.itkImageToImageFilterVIUC3IUC3):
    r"""Proxy of C++ itkBayesianClassifierImageFilterVIUC3UCFF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkBayesianClassifierImageFilterVIUC3UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkBayesianClassifierImageFilterVIUC3UCFF_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_Clone(self)

    def SetSmoothingFilter(self, arg0):
        r"""
        SetSmoothingFilter(self, arg0)

        Parameters
        ----------
        arg0: itkImageToImageFilterIF3IF3 *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_SetSmoothingFilter(self, arg0)

    def GetSmoothingFilter(self):
        r"""GetSmoothingFilter(self) -> itkImageToImageFilterIF3IF3_Pointer"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_GetSmoothingFilter(self)

    def SetPriors(self, arg0):
        r"""
        SetPriors(self, arg0)

        Parameters
        ----------
        arg0: itkVectorImageF3 const *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_SetPriors(self, arg0)

    def SetNumberOfSmoothingIterations(self, _arg):
        r"""
        SetNumberOfSmoothingIterations(self, _arg)

        Parameters
        ----------
        _arg: unsigned int

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_SetNumberOfSmoothingIterations(self, _arg)

    def GetNumberOfSmoothingIterations(self):
        r"""GetNumberOfSmoothingIterations(self) -> unsigned int"""
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_GetNumberOfSmoothingIterations(self)
    UnsignedIntConvertibleToLabelsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_UnsignedIntConvertibleToLabelsCheck
    
    PosteriorsAdditiveOperatorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_PosteriorsAdditiveOperatorsCheck
    
    IntConvertibleToPosteriorsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_IntConvertibleToPosteriorsCheck
    
    InputHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_InputHasNumericTraitsCheck
    
    PosteriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_PosteriorsHasNumericTraitsCheck
    
    PriorsHasNumericTraitsCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_PriorsHasNumericTraitsCheck
    
    InputPriorsPosteriorsMultiplyOperatorCheck = _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_InputPriorsPosteriorsMultiplyOperatorCheck
    
    __swig_destroy__ = _itkBayesianClassifierImageFilterPython.delete_itkBayesianClassifierImageFilterVIUC3UCFF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkBayesianClassifierImageFilterVIUC3UCFF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkBayesianClassifierImageFilterVIUC3UCFF

        Create a new object of the class itkBayesianClassifierImageFilterVIUC3UCFF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkBayesianClassifierImageFilterVIUC3UCFF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkBayesianClassifierImageFilterVIUC3UCFF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkBayesianClassifierImageFilterVIUC3UCFF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkBayesianClassifierImageFilterVIUC3UCFF in _itkBayesianClassifierImageFilterPython:
_itkBayesianClassifierImageFilterPython.itkBayesianClassifierImageFilterVIUC3UCFF_swigregister(itkBayesianClassifierImageFilterVIUC3UCFF)

from itk.support import helpers
import itk.support.types as itkt
from typing import Sequence, Tuple, Union

@helpers.accept_array_like_xarray_torch
def bayesian_classifier_image_filter(*args: itkt.ImageLike,  smoothing_filter=..., priors: itkt.VectorImage=..., number_of_smoothing_iterations: int=...,**kwargs)-> itkt.ImageSourceReturn:
    """Functional interface for BayesianClassifierImageFilter"""
    import itk

    kwarg_typehints = { 'smoothing_filter':smoothing_filter,'priors':priors,'number_of_smoothing_iterations':number_of_smoothing_iterations }
    specified_kwarg_typehints = { k:v for (k,v) in kwarg_typehints.items() if kwarg_typehints[k] is not ... }
    kwargs.update(specified_kwarg_typehints)


    instance = itk.BayesianClassifierImageFilter.New(*args, **kwargs)

    return instance.__internal_call__()

def bayesian_classifier_image_filter_init_docstring():
    import itk
    from itk.support import template_class

    filter_class = itk.ITKClassifiers.BayesianClassifierImageFilter
    bayesian_classifier_image_filter.process_object = filter_class
    is_template = isinstance(filter_class, template_class.itkTemplate)
    if is_template:
        filter_object = filter_class.values()[0]
    else:
        filter_object = filter_class

    bayesian_classifier_image_filter.__doc__ = filter_object.__doc__



