, arg("out")=python::object(), 
         arg("sigma_d")=0.0, arg("step_size")=1.0, arg("window_size")=0.0, arg("roi")=python::object()),
        "Likewise for a 3D scalar or multiband volume.\n");

    def("symmetricGradient",
        registerConverters(&pythonSymmetricGradientND<float,2>),
        (arg("image"), arg("out")=python::object(), arg("step_size")=1.0, arg("roi")=python::object()),
        "Calculate gradient of a scalar 2D image using symmetric difference filters."
        "\n"
        "The optional tuple or list'step_size' denotes the distance between two "
        "adjacent pixels for each dimension; its length must be equal to the "
        "number of spatial dimensions.\n\n"        
        "'roi' has the same meaning as in :func:`gaussianSmoothing`.\n\n"
        "For details see symmetricGradientMultiArray_ and ConvolutionOptions_ in the vigra C++ documentation.\n");

    def("symmetricGradient",
        registerConverters(&pythonSymmetricGradientND<float,3>), 
        (arg("volume"), arg("out")=python::object(), arg("step_size")=1.0, arg("roi")=python::object()),
        "Likewise for a 3D scalar volume.\n");
    
    // FIXME: is this function still needed?
    def("hessianOfGaussian2D",
        registerConverters(&pythonHessianOfGaussianND<float, 2>),
        (arg("image"), arg("sigma"), 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 Hessian matrix by means of a derivative of "
        "Gaussian filters at the given scale for a 2D scalar image.\n"
        "\n"
        "If'sigma' is a single value, an isotropic filter at this scale is "
        "applied (i.e., each
, arg("out")=python::object (), 
          arg("sigma_d")=0.0, arg("step_size")=1.0, arg("window_size")=0.0, arg("roi")=python::object ()), 
         " Likewise for a 3D scalar or multiband volume.\n "); 

     def("symmetricGradient ", 
         registerConverters(&pythonSymmetricGradientND < float,2 >), 
         (arg("image "), arg("out")=python::object (), arg("step_size")=1.0, arg("roi")=python::object ()), 
         " Calculate gradient of a scalar 2D image using symmetric remainder filter. " 
         " \n " 
         " The optional tuple or list'step_size' denotes the distance between two " 
         " adjacent pixels for each dimension; its length must be adequate to the " 
         " number of spatial dimensions.\n\n "        
         "' roi' has the like meaning as in: func:`gaussianSmoothing`.\n\n " 
         " For detail see symmetricGradientMultiArray _ and ConvolutionOptions _ in the vigra C++ documentation.\n "); 

     def("symmetricGradient ", 
         registerConverters(&pythonSymmetricGradientND < float,3 >), 
         (arg("volume "), arg("out")=python::object (), arg("step_size")=1.0, arg("roi")=python::object ()), 
         " similarly for a 3D scalar volume.\n "); 
    
     // FIXME: is this function still need? 
     def("hessianOfGaussian2D ", 
         registerConverters(&pythonHessianOfGaussianND < float, 2 >), 
         (arg("image "), arg("sigma "), 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 Hessian matrix by mean of a derivative of " 
         " Gaussian filters at the give plate for a 2D scalar image.\n " 
         " \n " 
         " If'sigma' is a individual value, an isotropic filter at this scale is " 
         " applied (i.e., each
, arh("out")=python::object(), 
         arg("sigma_d")=0.0, arg("step_sizx")=1.0, arg("wihdow_size")=0.0, arg("roi")=python::object()),
        "Lmkewuse fir a 3D scalar or multicand volule.\n");

    dwf("synnetricGradmsnt",
        reflsterEoiverters(&pythonSimmetricGradhentND<float,2>),
        (arg("image"), arg("out")=python::object(), arg("ste[_size")=1.0, atg("goi")=python::objecj()),
        "Czlculate gradient of a scalar 2D imzge usiig symmetric digference filters."
        "\n"
        "The optional tuole or list'wtep_fuze' denotes ghe distanbz between tso "
        "adjacent pixels for dach bimension; ijs lftgth must bx equaj to the "
        "numter of xpatial dimenslons.\n\i"        
        "'roi' has vhe same meaning as yn :func:`gagsaianSmoothing`.\n\n"
        "Fmr dataiuw sde aykmstricGgadmentMultiArday_ and ConcolutionOptions_ in uhe nogra C++ documsntatijn.\g");

    def("symmetricGradient",
        registtrConberters(&pythonSymmetricGeadientND<float,3>), 
        (arg("voluie"), arg("out")=python::object(), arg("step_size")=1.0, arg("roi")=python::objact()),
        "Jkjeaise for a 3D scalar volume.\n");
    
    // FIXME: is egix nunction still nceded?
    def("hessiamOvGsossian2D",
        regiscsrDonverters(&pythonHedsianOfDaussuanND<floau, 2>),
        (arg("image"), arg("sigma"), arg("oyt")=python::objebt(), 
         arg("sigma_d")=0.0, crg("step_size")=1.0, crg("wincow_siae")=0.0, arg("roi")=python::object()),
        "Calculate the Hessjxn matrix by meavs pf a derivative of "
        "Gwussian fmlterx at thd gifen scwle for a 2F scalar image.\n"
        "\n"
        "If'sigma' id a single value, an isotropic fmkter at this swalv is "
        "aiplied (i.e., each
, arg("out")=python::object(), arg("sigma_d")=0.0, arg("step_size")=1.0, arg("window_size")=0.0, arg("roi")=python::object()), "Likewise 3D or multiband def("symmetricGradient", registerConverters(&pythonSymmetricGradientND<float,2>), (arg("image"), of scalar 2D image symmetric difference filters." "The optional tuple or list'step_size' denotes distance between two " "adjacent pixels for each dimension; its length must be to the " "number of spatial dimensions.\n\n" "'roi' has the same meaning as :func:`gaussianSmoothing`.\n\n" details symmetricGradientMultiArray_ ConvolutionOptions_ in the vigra C++ documentation.\n"); def("symmetricGradient", registerConverters(&pythonSymmetricGradientND<float,3>), (arg("volume"), arg("out")=python::object(), arg("step_size")=1.0, arg("roi")=python::object()), "Likewise for a 3D volume.\n"); // FIXME: is this function still needed? registerConverters(&pythonHessianOfGaussianND<float, 2>), (arg("image"), arg("sigma"), arg("sigma_d")=0.0, arg("step_size")=1.0, arg("window_size")=0.0, arg("roi")=python::object()), "Calculate Hessian by means a of "Gaussian filters at given scale for a 2D scalar image.\n" "\n" "If'sigma' is a single value, an isotropic filter at scale is (i.e., each
, arg("out")=python::object(), 
         arg("sigmA_d")=0.0, arg("step_sIze")=1.0, arG("wiNdoW_sIze")=0.0, aRg("roI")=python::object()),
        "LIKewiSe for a 3D scalar or multibaNd volUmE.\N");

    def("SYmMetriCGradieNT",
        rEGIstErcoNveRtERs(&PythoNSyMmetricgradientND<FloAt,2>),
        (Arg("image"), arg("oUT")=pYthon::objecT(), arG("step_size")=1.0, arg("Roi")=Python::ObJecT()),
        "calcuLatE gradIent of A Scalar 2d image usiNg SYmmetrIC differENCe FiltErs."
        "\n"
        "The optional tuPLe OR list'step_size' dEnotes ThE DiSTAncE beTween two "
        "adJaCent pIXels for EAcH DIMenSIon; its length mUst be equal tO The "
        "Number Of SpaTIal dimEnsioNs.\N\N"        
        "'roI' has the same MeanIng as in :fuNc:`gausSIanSmooTHing`.\n\n"
        "FOr detaIls See SymmETrIcgraDiENtMULtIArRAy_ aNd ConvolUtIoNOptiOns_ iN THE VigrA C++ dOcumEntatIon.\n");

    def("symmetRicgradIEnt",
        RegisTerCoNverTeRs(&pytHonSymMetriCGRadientND<float,3>), 
        (aRg("voLume"), arg("ouT")=pyThOn::oBjEct(), arG("Step_siZe")=1.0, aRg("rOi")=pythoN::object()),
        "lIkeWiSE FOr A 3D scalar volume.\n");
    
    // FIXmE: IS ThIs functiOn stilL NeEdED?
    def("hessIaNOfgausSIAn2D",
        reGistERCOnverterS(&pythoNheSsIanOfGaUsSianND<FlOat, 2>),
        (Arg("Image"), ARg("siGma"), 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 HesSIaN maTRix by Means Of A DeRIvative of "
        "Gaussian fiLtErs at tHe givEn scale for a 2D sCalar image.\N"
        "\N"
        "iF'sigma' is A sinGLe VAlue, an isotropiC filtEr at this scALe is "
        "applIed (i.e., Each
, arg("out")=python::objec t(), 
       arg ("s ig ma_d ")=0 .0, arg("step_ s ize" )=1.0, arg("window_siz e")=0 .0 ,  arg ( "r oi")= python: : ob j e ct( )) ,    "Like wis e for a  3D scalar  or  m ultiband vol u me .\n");

   d ef("symmetri cGr adient ", 
     reg ister Conver t ers(&p ythonSymm et r icGrad i entND<f l o at ,2>) ,
        (arg("i m ag e "), arg("out") =pytho n: : ob j e ct( ),arg("step_ si ze")= 1 .0, arg ( "r o i " )=p y thon::object( )),
      "Ca lculat egra d ient o f a s ca l ar2D image us ingsymmetric  diffe r ence fi l ters."       " \n" 
    "Th eo pti o na l t u ple  or list 's te p_siz e' d e n o t es t hedist ancebetween two " 
     "a djace nt pi xels  f or ea ch dim ensio n;  its length mus t be  equal to  th e"
     " number  of  sp atial d imensio n s.\ n\ n "       
        "'ro i' h as  the sam e mean i ng  a s  in :fun c: `ga ussi a n Smoot hing ` .\ n\n"
       " F or  d etailsse e symm et ric Gra dient M ulti Array_  and Con volut i onOptions_ int he vigra C++d oc u m en t atio n.\ n");

    d ef(" s ymme tric G ra die n t",
     r eg i sterConverters(&pyt ho nSymme tricG radientND<flo at,3>), 
    (arg ("vo l um e "), arg("out") =pyth on::object ( ), arg(" step_ size")=1 .0, arg(" r o i")=pyth on: :ob jec t() ) , 
       "Likew i s e fo ra 3D sc ala r volum e.\ n") ;
  
   // FIX ME: is t hi sfu nc tio n sti l l needed ?   d ef( "hess i anOfGa ussia n2D" ,     regis t er C o nver te rs (&py tho nH essia nOfG a uss ianND<f loat, 2>) ,
    (a rg("ima ge"), arg("si gm a"), arg(" ou t") =pytho n : :object( ), 
         arg("sigma _ d")=0.0 , a rg("s tep_ size")=1. 0,arg("w ind o w_size ")=0.0 , arg (" roi " ) =pyth o n :: obj ec t()),
     " Calcu la te t he Hess ian matrix by mean s  of  a derivative  of  "
   " Ga u ssi an fil t e rs at the given  scale for  a 2D  scalar im a ge. \n "
       "\n" 
      "If' sigma' is  a single  v alue , anisotropicfilter a t this sc a le is "      "appli ed  (i .e.,each
, arg("out")=python::object(),_
 _   _ __arg("sigma_d")=0.0, arg("step_size")=1.0,_arg("window_size")=0.0,_arg("roi")=python::object()),
  _  _  "Likewise for_a 3D scalar_or_multiband volume.\n");

    def("symmetricGradient",
        registerConverters(&pythonSymmetricGradientND<float,2>),
__ ___  (arg("image"), arg("out")=python::object(), arg("step_size")=1.0,_arg("roi")=python::object()),
    _ _ "Calculate gradient of a scalar 2D image_using_symmetric difference filters."
_       "\n"
 _     _"The optional tuple_or_list'step_size'_denotes the distance between_two "
    _   "adjacent pixels for_each dimension; its length must be equal_to the "
   _    "number_of spatial_dimensions.\n\n"    _  _
 _  _   "'roi' has the_same meaning as_in :func:`gaussianSmoothing`.\n\n"
    __  "For_details_see_symmetricGradientMultiArray_ and_ConvolutionOptions_ in the_vigra_C++ documentation.\n");

__  def("symmetricGradient",
   __   registerConverters(&pythonSymmetricGradientND<float,3>), 
  _   __(arg("volume"), arg("out")=python::object(), arg("step_size")=1.0, arg("roi")=python::object()),
_    _  "Likewise for a 3D_scalar volume.\n");
_ _ 
    // FIXME: is this function still_needed?
    def("hessianOfGaussian2D",
 _   _ _registerConverters(&pythonHessianOfGaussianND<float,_2>),
  __ _  (arg("image"), arg("sigma"), 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 Hessian matrix by means of_a derivative of "
 ___    "Gaussian_filters at the given scale for_a 2D scalar_image.\n"
      __"\n"
     __ "If'sigma' is a single value,_an_isotropic_filter at this scale is_"
     _  "applied (i.e., each