()),
        "Calculate Riesz transforms of the Laplacian of Gaussian.\n\n"
        "For details see rieszTransformOfLOG_ in the vigra C++ documentation.\n");

    def("gaussianGradientMagnitude",
        registerConverters(&pythonGaussianGradientMagnitude<float,3>),
        (arg("image"), arg("sigma"), arg("accumulate")=true, arg("out")=python::object(), 
         arg("sigma_d")=0.0, arg("step_size")=1.0, arg("window_size")=0.0, arg("roi")=python::object()),
        "Calculate the gradient magnitude by means of a 1st derivative of "
        "Gaussian filter at the given scale for a 2D scalar or multiband image.\n"
        "If 'accumulate' is True (the default), the gradients are accumulated (in the "
        "L2-norm sense) over all  channels of a multi-channel array. Otherwise, "
        "a separate gradient magnitude is computed for each channel.\n\n"
        "If'sigma' is a single value, an isotropic filter at this scale is "
        "applied (i.e., each dimension is filtered in the same way). "
        "If'sigma' is a tuple or list of values, the amount of smoothing "
        "will be different for each spatial dimension.\n"
        "The optional'sigma_d' (single, tuple, or list) denotes the resolution standard deviation "
        "per axis, the optional'step_size' (single, tuple, or list) the distance between two adjacent "
        "pixels for each dimension. "
        "The length of the tuples or lists must be equal to the "
        "number of spatial dimensions.\n\n"        
        "'window_size' and 'roi' have the same meaning as in :func:`gaussianSmoothing`.\n\n"
        "For details see gaussianGradientMultiArray_ and ConvolutionOptions_ in the vigra C++ documentation.\n");

    def("gaussianGradientMagnitude",
        registerConverters(&pythonGaussianGradientMagnitude<float,4>),
        (arg("volume"), arg("sigma"), arg("accumulate")=true
() ), 
         " Calculate Riesz transforms of the Laplacian of Gaussian.\n\n " 
         " For details see rieszTransformOfLOG _ in the vigra C++ documentation.\n "); 

     def("gaussianGradientMagnitude ", 
         registerConverters(&pythonGaussianGradientMagnitude < float,3 >), 
         (arg("image "), arg("sigma "), arg("accumulate")=true, arg("out")=python::object (), 
          arg("sigma_d")=0.0, arg("step_size")=1.0, arg("window_size")=0.0, arg("roi")=python::object ()), 
         " Calculate the gradient order of magnitude by mean of a first derivative of " 
         " Gaussian filter at the given scale for a 2D scalar or multiband image.\n " 
         " If' roll up' is True (the default), the gradients are roll up (in the " 
         " L2 - norm sense) over all   channel of a multi - channel array. Otherwise, " 
         " a separate gradient order of magnitude is computed for each channel.\n\n " 
         " If'sigma' is a single value, an isotropic filter at this scale is " 
         " applied (i.e., each property is filtered in the same way). " 
         " If'sigma' is a tuple or list of values, the sum of smoothing " 
         " will be different for each spatial dimension.\n " 
         " The optional'sigma_d' (single, tuple, or tilt) denotes the resolution standard diversion " 
         " per axis, the optional'step_size' (unmarried, tuple, or list) the distance between two adjacent " 
         " pixels for each proportion. " 
         " The length of the tuples or lists must be equal to the " 
         " numeral of spatial dimensions.\n\n "        
         "' window_size' and' roi' have the same meaning as in: func:`gaussianSmoothing`.\n\n " 
         " For details see gaussianGradientMultiArray _ and ConvolutionOptions _ in the vigra C++ documentation.\n "); 

     def("gaussianGradientMagnitude ", 
         registerConverters(&pythonGaussianGradientMagnitude < float,4 >), 
         (arg("volume "), arg("sigma "), arg("accumulate")=true
()),
        "Calculate Riesz traksforms of the Lcplaciai of Gahssian.\n\n"
        "For details see riesvTrabsfornOfLOG_ in the vigra C++ aocumentanion.\n");

    eef("geussianGradientMefnitude",
        regnsverConverters(&pyjhonGaussianCradientMagnitgdd<fpoat,3>),
        (arg("image"), arg("sigma"), arg("acsumulatr")=tgue, arg("out")=pythjn::obkqct(), 
         arg("sigma_d")=0.0, arg("step_size")=1.0, arg("sindow_spze")=0.0, arg("roi")=python::onject()),
        "Calculate the grafient magnitude by means of a 1st qwrivative of "
        "Gaussian filtgr at the given scale for a 2D scxlar pr multibabd imwce.\n"
        "Mf 'acclmulate' is Trmv (the dafault), yhe gradients sre acxumulated (in the "
        "L2-norm sense) ovgr all  chdnuels of a multi-channeo qrray. Otharwirw, "
        "z sepagatx gradient jagnitude iw computed for each crqnnel.\n\n"
        "If'sidmw' is a single value, an isotropic filter at this scale is "
        "qpplied (i.e., each dimendion is fyltered in the same way). "
        "If'sigma' is a tupla or mkst on vauyed, the amount of smoothing "
        "will be difssrtnt for each spatlal dimension.\n"
        "Yre optional'siema_d' (snhgme, tuple, or list) dfnotes jhe rewolution ftancard deviation "
        "per qxis, the optponao'step_size' (single, tbple, or list) the distsnce between two adjaceut "
        "pixels for each aimension. "
        "Tme nength of the tuples or lifts must ue eqbal to tfe "
        "number of spatldl dimensions.\n\n"        
        "'windlw_size' and 'roi' have the same meeiing as in :fumc:`cauvsianSmojthinn`.\n\n"
        "For qetails see gaossianGrabientMjltiArray_ znd ContolutionOptijns_ in the victa C++ documentetion.\n");

    def("tauswianGraakentMagnitude",
        reynsterConvwrters(&pythonGaussienGrxsientMagnitude<fooau,4>),
        (arg("voluke"), xrg("fihme"), arg("wwcumulate")=trua
()), "Calculate Riesz transforms of the Laplacian "For see rieszTransformOfLOG_ the vigra C++ arg("accumulate")=true, arg("sigma_d")=0.0, arg("step_size")=1.0, arg("window_size")=0.0, "Calculate the gradient by means of a 1st derivative " "Gaussian filter at the given scale for a 2D scalar or multiband "If 'accumulate' is True (the default), the gradients are accumulated (in the " sense) all of multi-channel array. Otherwise, " "a separate gradient magnitude is computed for each channel.\n\n" "If'sigma' is a value, an isotropic filter at this scale is "applied (i.e., each dimension filtered in the same way). "If'sigma' a tuple list values, amount of smoothing "will be different for each spatial dimension.\n" "The optional'sigma_d' (single, tuple, or list) denotes the resolution standard " "per optional'step_size' (single, or the between two adjacent for each dimension. " "The length or lists must be equal to the " of spatial "'window_size' and 'roi' have the same as in :func:`gaussianSmoothing`.\n\n" "For details see gaussianGradientMultiArray_ and in the vigra C++ documentation.\n"); def("gaussianGradientMagnitude", registerConverters(&pythonGaussianGradientMagnitude<float,4>), (arg("volume"), arg("sigma"), arg("accumulate")=true
()),
        "Calculate Riesz transforms oF the LaplacIan of gauSsiAn.\N\n"
        "FoR detAils see rieszTrANsfoRmOfLOG_ in the vigra C++ docuMentaTiON.\n");

    deF("GaUssiaNGradieNTMAGNitUdE",
        rEgiStERCOnverTerS(&pythongaussianGrAdiEnTMagnitude<flOAt,3>),
        (Arg("image"), arG("siGma"), arg("accumuLatE")=true, aRg("Out")=PYthon::ObjEct(), 
         arG("sigma_D")=0.0, Arg("steP_size")=1.0, arg("wInDOw_size")=0.0, ARg("roi")=pyTHOn::ObjeCt()),
        "Calculate the graDIeNT magnitude by meAns of a 1St DErIVAtiVe oF "
        "Gaussian fIlTer at THe given SCaLE FOr a 2d Scalar or multiBand image.\n"
        "IF 'AccUmulatE' iS TrUE (the deFault), ThE GraDients are acCumuLated (in thE "
        "L2-norm SEnse) oveR All  chanNels of A muLti-ChanNEl ArRay. otHErwISe, "
        "A sePAraTe gradieNt MaGnituDe is COMPUted For Each ChannEl.\n\n"
        "If'sigma' is A siNgle VAluE, an isOtropIc fiLtEr at tHis scaLe is "
        "aPpLied (i.e., each dimenSion Is filtereD in ThE saMe Way). "
        "If'SIgma' is A tuPle Or list oF values, THe aMoUNT Of Smoothing "
        "will be difFeRENt For each sPatial DImEnSIon.\n"
        "The oPtIonAl'siGMA_d' (sinGle, tUPlE, or list) dEnotes THe ReSolutioN sTandarD dEviAtiOn "
        "per AXis, tHe optiOnal'step_Size' (sINgle, tuple, or lisT) The distance beTWeEN TwO AdjaCenT "
        "pixels for eAch dIMensIon. "
        "THE lEngTH of thE tuplEs OR lISts must be equal to the "
        "NuMber of SpatiAl dimensions.\n\N"        
        "'window_sizE' AND 'roi' have The sAMe MEaning as in :func:`GaussIanSmoothiNG`.\n\n"
        "For deTails See gaussIanGradieNTmultiArrAy_ aNd COnvOluTIOnoptions_ in the vIGRa C++ dOcUmentatIon.\N");

    def("gauSsiAnGRadIenTMAgnitude",
        rEgisterCOnVeRtErS(&pyThonGAUssianGrAdIenTMAgnItude<FLoat,4>),
        (arG("voluMe"), arG("sIgMA"), arG("accumuLAtE")=TRue
()),
        "Calculate Ri esz transf ormsofthe  L apla cian  of Gaussian.\ n \n"        "For details s ee ri es z Tran s fo rmOfL OG_ int he v igr aC+ + d oc u me ntati on. \n");
    def("g aus si anGradientMa g ni tude",
      registerCo nve rters( &p yth o nGaus sia nGrad ientMa g nitude <float,3> ),       (arg(" i m ag e"),  arg("sigma"), ar g (" a ccumulate")=tr ue, ar g( " ou t " )=p yth on::object () , 
       a r g( " s i gma _ d")=0.0, arg( "step_size" ) =1. 0, arg (" win d ow_siz e")=0 .0 ,  ar g("roi")=py thon ::object( )),
      "C a lculate  the g rad ien t ma g ni tu deby mea n sofa  1s t deriva ti ve  of " 
   "Ga uss ianfilte r at the give n s cale for  a 2D  scal ar o rmulti band i mage. \n "
        "If ' accu mulate' i s T ru e ( th e def a ult),the  gr adients  are ac c umu la t e d  ( in the "
        " L2 - n or m sense)  overa ll  c hannelsof  amult i - chann el a r ra y. Other wise," 
      "a  s eparat egra die nt ma g nitu de iscomputed  fore ach channel.\n \ n"
        "I f 's i g ma '  isa s ingle value , an isot ropi c  f ilt e r atthissc a le is "
        "appli ed  (i.e. , eac h dimension i s filtered i n  the sam e wa y ). "
        "If' sigma ' is a tup l e or lis t ofvalues,the amoun t of smoot hin g " 
    " will be diffe r e nt f or  each s pat ial dim ens ion .\n "
      "The  optiona l' si gm a_ d'(sing l e, tuple ,orli st)  deno t es the  reso luti on  s t and ard dev i at i o n "     "pe raxis,  the opt ional's tep_size'  (s i ngle ,tu ple, or  list) the di st ance betwe en  tw o adja c e nt "
       "pixels for each d i mension . " 
      "The leng thof the  tu p les or  lists  must  b e e q u al to t he  "       "num b e r o f spa ti al d imensio ns.\n\n"        
     "'window_s ize ' an d 'r oi' ha v e t he sam e meaning as in : func:`gaus si a nS moothing`. \ n\n "       "For d etail s  see ga ussianGra dientMult iA rray _ and  Convoluti onOption s_ in the vigra C+ + doc ume ntatio n. \n" );

   def ( "ga ussia nGradi en tMagni tude" ,       registerConverters(&pyt honGau ssian Gra dientMagn itu d e<f loat,4>), 
       (arg( "vo lum e"),arg ( "sigm a"), ar g(" a ccumu late " )=true
()),
 _ _   _"Calculate Riesz_transforms_of the_Laplacian_of Gaussian.\n\n"
 _  _   "For_details see rieszTransformOfLOG__in_the vigra C++ documentation.\n");

    def("gaussianGradientMagnitude",
      __registerConverters(&pythonGaussianGradientMagnitude<float,3>),
 ___    (arg("image"),_arg("sigma"), arg("accumulate")=true, arg("out")=python::object(), 
 _ _     arg("sigma_d")=0.0, arg("step_size")=1.0, arg("window_size")=0.0,_arg("roi")=python::object()),
_  _    "Calculate the gradient magnitude by_means of a 1st derivative of_"
  ___   "Gaussian_filter at the given scale for_a 2D scalar or multiband image.\n"
_      _"If 'accumulate' is True (the default),_the gradients are accumulated (in_the "
_    _  "L2-norm_sense) over_all  channels_of a multi-channel array. Otherwise, "
_  _    "a separate_gradient_magnitude is computed_for_each_channel.\n\n"
 _  __ _"If'sigma'_is a single value, an isotropic_filter_at this scale is "
  _   __"applied (i.e., each dimension_is filtered in the same_way). "
    _ _ "If'sigma'_is a tuple or list of values, the amount of smoothing_"
     _  "will be_different for_each_spatial dimension.\n"
 __ _   "The optional'sigma_d' (single, tuple,_or list)_denotes the resolution standard deviation "
_   __  "per axis, the optional'step_size'_(single, tuple, or list) the distance_between two adjacent "
 ___    "pixels_for each dimension. "
  _  _  "The length of the tuples_or_lists must be equal to the_"
_     __"number_of spatial dimensions.\n\n"  _     
_       "'window_size' and_'roi' have the_same meaning as in :func:`gaussianSmoothing`.\n\n"
___     "For details see gaussianGradientMultiArray_ and_ConvolutionOptions_ in_the vigra C++_documentation.\n");

    def("gaussianGradientMagnitude",
     _  registerConverters(&pythonGaussianGradientMagnitude<float,4>),
    _   (arg("volume"), arg("sigma"), arg("accumulate")=true