Skip to content
Snippets Groups Projects
Commit 17361082 authored by Manuel Günther's avatar Manuel Günther
Browse files

Removed traces of Gabor jets and Gabor graphs (now in bob.ip.gabor).

parent 74c0702a
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
bob/learn/misc/GaborWaveletTransform.cpp deleted 100644 → 0
+ 0
− 314
View file @ 74c0702a
/**
* @author Manuel Guenther <Manuel.Guenther@idiap.ch>
* @date 2012-02-27
*
* @brief Binds the Gabor wavelet transform
*
* Copyright (C) 2011-2014 Idiap Research Institute, Martigny, Switzerland
*/
#include "ndarray.h"
#include <bob/core/array_type.h>
#include <bob/ip/GaborWaveletTransform.h>
#include <bob/sp/FFT2D.h>
#include <blitz/array.h>
#include "bob/core/cast.h"
#include "bob/ip/color.h"
template <class T>
static inline const blitz::Array<std::complex<double>,2> complex_cast (bob::python::const_ndarray input){
blitz::Array<T,2> gray(input.type().shape[1],input.type().shape[2]);
bob::ip::rgb_to_gray(input.bz<T,3>(), gray);
return bob::core::array::cast<std::complex<double> >(gray);
}
static inline const blitz::Array<std::complex<double>, 2> convert_image(bob::python::const_ndarray input){
if (input.type().nd == 3){
// perform color type conversion
switch (input.type().dtype){
case bob::core::array::t_uint8: return complex_cast<uint8_t>(input);
case bob::core::array::t_uint16: return complex_cast<uint16_t>(input);
case bob::core::array::t_float64: return complex_cast<double>(input);
default: throw std::runtime_error("unsupported input data type");
}
} else {
switch (input.type().dtype){
case bob::core::array::t_uint8: return bob::core::array::cast<std::complex<double> >(input.bz<uint8_t,2>());
case bob::core::array::t_uint16: return bob::core::array::cast<std::complex<double> >(input.bz<uint16_t,2>());
case bob::core::array::t_float64: return bob::core::array::cast<std::complex<double> >(input.bz<double,2>());
case bob::core::array::t_complex128: return input.bz<std::complex<double>,2>();
default: throw std::runtime_error("unsupported input data type");
}
}
}
static inline void transform (bob::ip::GaborKernel& kernel, blitz::Array<std::complex<double>,2>& input, blitz::Array<std::complex<double>,2>& output){
// perform fft on input image
bob::sp::FFT2D fft(input.extent(0), input.extent(1));
blitz::Array<std::complex<double>,2> tmp(input.shape());
fft(input, output);
// apply the kernel in frequency domain
kernel.transform(output, tmp);
// perform ifft on the result
bob::sp::IFFT2D ifft(output.extent(0), output.extent(1));
ifft(tmp, output);
}
static void gabor_wavelet_transform_1 (bob::ip::GaborKernel& kernel, bob::python::const_ndarray input_image, bob::python::ndarray output_image){
// convert input image into complex type
blitz::Array<std::complex<double>,2> input = convert_image(input_image);
// cast output image to complex type
blitz::Array<std::complex<double>,2> output = output_image.bz<std::complex<double>,2>();
// transform input to output
transform(kernel, input, output);
}
static blitz::Array<std::complex<double>,2> gabor_wavelet_transform_2 (bob::ip::GaborKernel& kernel, bob::python::const_ndarray input_image){
// convert input ndarray to complex blitz array
blitz::Array<std::complex<double>,2> input = convert_image(input_image);
// allocate output array
blitz::Array<std::complex<double>,2> output(input.extent(0), input.extent(1));
// transform input to output
transform(kernel, input, output);
// return the nd array
return output;
}
static blitz::Array<std::complex<double>,3> empty_trafo_image (bob::ip::GaborWaveletTransform& gwt, bob::python::const_ndarray input_image){
int index = input_image.type().nd-2;
assert(index >= 0);
return blitz::Array<std::complex<double>,3>(gwt.numberOfKernels(), input_image.type().shape[index], input_image.type().shape[index+1]);
}
static void perform_gwt_1 (bob::ip::GaborWaveletTransform& gwt, bob::python::const_ndarray input_image, bob::python::ndarray output_trafo_image){
const blitz::Array<std::complex<double>,2>& image = convert_image(input_image);
blitz::Array<std::complex<double>,3> trafo_image = output_trafo_image.bz<std::complex<double>,3>();
gwt.performGWT(image, trafo_image);
}
static blitz::Array<std::complex<double>,3> perform_gwt_2 (bob::ip::GaborWaveletTransform& gwt, bob::python::const_ndarray input_image){
const blitz::Array<std::complex<double>,2>& image = convert_image(input_image);
blitz::Array<std::complex<double>,3> trafo_image(gwt.numberOfKernels(), image.shape()[0], image.shape()[1]);
gwt.performGWT(image, trafo_image);
return trafo_image;
}
static bob::python::ndarray empty_jet_image(bob::ip::GaborWaveletTransform& gwt, bob::python::const_ndarray input_image, bool include_phases){
const blitz::Array<std::complex<double>,2>& image = convert_image(input_image);
if (include_phases)
return bob::python::ndarray (bob::core::array::t_float64, image.extent(0), image.extent(1), 2, (int)gwt.numberOfKernels());
else
return bob::python::ndarray (bob::core::array::t_float64, image.extent(0), image.extent(1), (int)gwt.numberOfKernels());
}
static void compute_jets_1(bob::ip::GaborWaveletTransform& gwt, bob::python::const_ndarray input_image, bob::python::ndarray output_jet_image, bool normalized){
const blitz::Array<std::complex<double>,2>& image = convert_image(input_image);
if (output_jet_image.type().nd == 3){
// compute jet image with absolute values only
blitz::Array<double,3> jet_image = output_jet_image.bz<double,3>();
gwt.computeJetImage(image, jet_image, normalized);
} else if (output_jet_image.type().nd == 4){
blitz::Array<double,4> jet_image = output_jet_image.bz<double,4>();
gwt.computeJetImage(image, jet_image, normalized);
} else {
boost::format m("parameter `output_jet_image' has an unexpected shape: %s");
m % output_jet_image.type().str();
throw std::runtime_error(m.str());
}
}
static bob::python::ndarray compute_jets_2(bob::ip::GaborWaveletTransform& gwt, bob::python::const_ndarray input_image, bool include_phases, bool normalized){
bob::python::ndarray output_jet_image = empty_jet_image(gwt, input_image, include_phases);
compute_jets_1(gwt, input_image, output_jet_image, normalized);
return output_jet_image;
}
static void normalize_gabor_jet(bob::python::ndarray gabor_jet){
if (gabor_jet.type().nd == 1){
blitz::Array<double,1> jet(gabor_jet.bz<double,1>());
bob::ip::normalizeGaborJet(jet);
} else if (gabor_jet.type().nd == 2){
blitz::Array<double,2> jet(gabor_jet.bz<double,2>());
bob::ip::normalizeGaborJet(jet);
} else {
boost::format m("parameter `gabor_jet' has an unexpected shape: %s");
m % gabor_jet.type().str();
throw std::runtime_error(m.str());
}
}
void bind_ip_gabor_wavelet_transform() {
// bind Gabor Kernel class
boost::python::class_<bob::ip::GaborKernel, boost::shared_ptr<bob::ip::GaborKernel> >(
"GaborKernel",
"This class can be used to filter an image with a single Gabor wavelet.",
boost::python::no_init
)
.def(
boost::python::init< const blitz::TinyVector<int,2>&, const blitz::TinyVector<double,2>&, boost::python::optional <const double, const double, const bool, const double> >(
(
boost::python::arg("self"),
boost::python::arg("resolution"),
boost::python::arg("wavelet_frequency"),
boost::python::arg("sigma") = 2. * M_PI,
boost::python::arg("pow_of_k") = 0.,
boost::python::arg("dc_free") = true,
boost::python::arg("epsilon") = 1e-10
),
"Initializes the Gabor wavelet of the given wavelet frequency to be used as a filter for the given image resolution. The optional parameters can be changed, but have useful default values."
)
)
.def(boost::python::init<bob::ip::GaborKernel&>((boost::python::arg("self"), boost::python::arg("other"))))
.def(boost::python::self == boost::python::self)
.def(boost::python::self != boost::python::self)
.def(
"__call__",
&gabor_wavelet_transform_1,
(boost::python::arg("self"), boost::python::arg("input_image"), boost::python::arg("output_image")),
"This function Gabor-filters the given input_image, which can be of any type, to the output image. The output image needs to have the same resolution as the input image and must be of complex type."
)
.def(
"__call__",
&gabor_wavelet_transform_2,
(boost::python::arg("self"), boost::python::arg("input_image")),
"This function Gabor-filters the given input_image, which can be of any type. The output image is of complex type. It will be automatically generated and returned."
);
// declare GWT class
boost::python::class_<bob::ip::GaborWaveletTransform, boost::shared_ptr<bob::ip::GaborWaveletTransform> >(
"GaborWaveletTransform",
"This class can be used to perform a Gabor wavelet transform from one image to an image of (normalized) Gabor jets or to a complex-valued multi-layer trafo image.",
boost::python::no_init
)
.def(
boost::python::init<boost::python::optional<int,int,double,double,double,double,bool> >(
(
boost::python::arg("self"),
boost::python::arg("number_of_scales") = 5,
boost::python::arg("number_of_angles") = 8,
boost::python::arg("sigma") = 2. * M_PI,
boost::python::arg("k_max") = M_PI / 2.,
boost::python::arg("k_fac") = 1./sqrt(2.),
boost::python::arg("pow_of_k") = 0.,
boost::python::arg("dc_free") = true
),
"Initializes the Gabor wavelet transform by generating Gabor wavelets in number_of_scales different frequencies and number_of_angles different directions. The remaining parameters are parameters of the Gabor wavelets to be generated. "
)
)
.def(boost::python::init<bob::ip::GaborWaveletTransform&>((boost::python::arg("self"), boost::python::arg("other"))))
.def(boost::python::init<bob::io::HDF5File&>((boost::python::arg("self"), boost::python::arg("config"))))
.def(boost::python::self == boost::python::self)
.def(boost::python::self != boost::python::self)
.def(
"save",
&bob::ip::GaborWaveletTransform::save,
(boost::python::arg("self"), boost::python::arg("config")),
"Saves the parameterization of this Gabor wavelet transform to HDF5 file."
)
.def(
"load",
&bob::ip::GaborWaveletTransform::load,
(boost::python::arg("self"), boost::python::arg("config")),
"Loads the parameterization of this Gabor wavelet transform from HDF5 file."
)
.add_property(
"number_of_kernels",
&bob::ip::GaborWaveletTransform::numberOfKernels,
"The number of Gabor wavelets (i.e. number of directions times number of scales, i.e. the length of a Gabor jet, i.e. the number of layers of the trafo image) used in this Gabor wavelet transform."
)
.add_property(
"number_of_scales",
&bob::ip::GaborWaveletTransform::numberOfScales,
"The number of scales that this Gabor wavelet family holds."
)
.add_property(
"number_of_directions",
&bob::ip::GaborWaveletTransform::numberOfDirections,
"The number of directions that this Gabor wavelet family holds."
)
.def(
"empty_trafo_image",
&empty_trafo_image,
(boost::python::arg("self"), boost::python::arg("input_image")),
"This function creates an empty trafo image for the given input image. Use this function to generate the trafo image in the correct size and with the correct data type. In case you have to transform multiple images of the same size, this trafo image can be reused."
)
.def(
"perform_gwt",
&perform_gwt_1,
(boost::python::arg("self"), boost::python::arg("input_image"), boost::python::arg("output_trafo_image")),
"Performs a Gabor wavelet transform and fills the given Gabor wavelet transformed image (output_trafo_image)"
)
.def(
"perform_gwt",
&perform_gwt_2,
(boost::python::arg("self"), boost::python::arg("input_image")),
"Performs a Gabor wavelet transform and returns a Gabor wavelet transformed image"
)
.def(
"__call__",
&perform_gwt_1,
(boost::python::arg("self"), boost::python::arg("input_image"), boost::python::arg("output_trafo_image")),
"Performs a Gabor wavelet transform and fills the given Gabor wavelet transformed image (output_trafo_image)"
)
.def(
"__call__",
&perform_gwt_2,
(boost::python::arg("self"), boost::python::arg("input_image")),
"Performs a Gabor wavelet transform and returns a Gabor wavelet transformed image"
)
.def(
"empty_jet_image",
&empty_jet_image,
(boost::python::arg("self"), boost::python::arg("input_image"), boost::python::arg("include_phases")=true),
"This function creates an empty jet image (with or without Gabor phases) for the given input image. Use this function to generate the jet image in the correct size and with the correct data type. In case you have to transform multiple images of the same size, this jet image can be reused."
)
.def(
"compute_jets",
&compute_jets_1,
(boost::python::arg("self"), boost::python::arg("input_image"), boost::python::arg("output_jet_image"), boost::python::arg("normalized")=true),
"Performs a Gabor wavelet transform and fills given image of Gabor jets. If the normalized parameter is set to True (the default), the absolute parts of the Gabor jets are normalized to unit Euclidean length."
)
.def(
"compute_jets",
&compute_jets_2,
(boost::python::arg("self"), boost::python::arg("input_image"), boost::python::arg("include_phases")=true, boost::python::arg("normalized")=true),
"Performs a Gabor wavelet transform and returns the image of Gabor jets, with or without Gabor phases. If the normalized parameter is set to True (the default), the absolute parts of the Gabor jets are normalized to unit Euclidean length."
);
boost::python::def(
"normalize_gabor_jet",
&normalize_gabor_jet,
(boost::python::arg("gabor_jet")),
"Normalizes the Gabor jet (with or without phase) to unit Euclidean length."
);
}
bob/learn/misc/gabor.cpp deleted 100644 → 0
+ 0
− 274
View file @ 74c0702a
/**
* @date 2012-03-05
* @author Manuel Guenther <Manuel.Guenther@idiap.ch>
*
* @brief Bindings for the GaborGraphMachine and several GaborJetSimilarities
*
* Copyright (C) 2011-2014 Idiap Research Institute, Martigny, Switzerland
*/
#include "ndarray.h"
#include <bob/ip/GaborWaveletTransform.h>
#include <bob/machine/GaborGraphMachine.h>
#include <bob/machine/GaborJetSimilarities.h>
static void bob_extract(bob::machine::GaborGraphMachine& self, bob::python::const_ndarray input_jet_image, bob::python::ndarray output_graph){
if (output_graph.type().nd == 2){
blitz::Array<double,2> graph = output_graph.bz<double,2>();
self.extract(input_jet_image.bz<double,3>(), graph);
} else if (output_graph.type().nd == 3){
blitz::Array<double,3> graph = output_graph.bz<double,3>();
self.extract(input_jet_image.bz<double,4>(), graph);
} else {
PYTHON_ERROR(RuntimeError, "parameter `output_graph' should be 2 or 3 dimensional, but you passed a " SIZE_T_FMT " dimensional array.", output_graph.type().nd);
}
}
static bob::python::ndarray bob_extract2(bob::machine::GaborGraphMachine& self, bob::python::const_ndarray input_jet_image){
if (input_jet_image.type().nd == 3){
const blitz::Array<double,3> jet_image = input_jet_image.bz<double,3>();
bob::python::ndarray output_graph(bob::core::array::t_float64, self.numberOfNodes(), jet_image.shape()[2]);
blitz::Array<double,2> graph = output_graph.bz<double,2>();
self.extract(jet_image, graph);
return output_graph;
} else if (input_jet_image.type().nd == 4){
const blitz::Array<double,4> jet_image = input_jet_image.bz<double,4>();
bob::python::ndarray output_graph(bob::core::array::t_float64, self.numberOfNodes(), jet_image.shape()[2], jet_image.shape()[3]);
blitz::Array<double,3> graph = output_graph.bz<double,3>();
self.extract(jet_image, graph);
return output_graph;
} else {
PYTHON_ERROR(RuntimeError, "parameter `input_jet_image' should be 3 or 4 dimensional, but you passed a " SIZE_T_FMT " dimensional array.", input_jet_image.type().nd);
}
}
static void bob_average(bob::machine::GaborGraphMachine& self, bob::python::const_ndarray many_graph_jets, bob::python::ndarray averaged_graph_jets){
blitz::Array<double,3> graph = averaged_graph_jets.bz<double,3>();
self.average(many_graph_jets.bz<double,4>(), graph);
}
static double bob_similarity(bob::machine::GaborGraphMachine& self, bob::python::const_ndarray model_graph, bob::python::ndarray probe_graph, const bob::machine::GaborJetSimilarity& similarity_function){
switch (probe_graph.type().nd){
case 2:{ // Gabor graph including jets without phases
blitz::Array<double,2> probe = probe_graph.bz<double,2>();
switch (model_graph.type().nd){
case 2:{
return self.similarity(model_graph.bz<double,2>(), probe, similarity_function);
}
case 3:{
return self.similarity(model_graph.bz<double,3>(), probe, similarity_function);
}
default:
PYTHON_ERROR(RuntimeError, "parameter `model_graph' should be 2 or 3 dimensional (because `probe_graph' is 2D), but you passed a " SIZE_T_FMT " dimensional array.", model_graph.type().nd);
}
}
case 3:{ // Gabor graph including jets with phases
blitz::Array<double,3> probe = probe_graph.bz<double,3>();
switch (model_graph.type().nd){
case 3:{
return self.similarity(model_graph.bz<double,3>(), probe, similarity_function);
}
case 4:{
return self.similarity(model_graph.bz<double,4>(), probe, similarity_function);
}
default:
PYTHON_ERROR(RuntimeError, "parameter `model_graph' should be 3 or 4 dimensional (because `probe_graph' is 3D), but you passed a " SIZE_T_FMT " dimensional array.", model_graph.type().nd);
}
}
default: // unknown graph shape
PYTHON_ERROR(RuntimeError, "parameter `probe_graph' should be 2 or 3 dimensional, but you passed a " SIZE_T_FMT " dimensional array.", probe_graph.type().nd);
}
}
static double bob_jet_sim(const bob::machine::GaborJetSimilarity& self, bob::python::const_ndarray jet1, bob::python::const_ndarray jet2){
switch (jet1.type().nd){
case 1:{
return self(jet1.bz<double,1>(), jet2.bz<double,1>());
}
case 2:{
return self(jet1.bz<double,2>(), jet2.bz<double,2>());
}
default:
PYTHON_ERROR(RuntimeError, "parameter `jet1' should be 1 or 2 dimensional, but you passed a " SIZE_T_FMT " dimensional array.", jet1.type().nd);
}
}
static blitz::Array<double,2> bob_jet_shift_phase(const bob::machine::GaborJetSimilarity& self, const blitz::Array<double,2>& jet, const blitz::Array<double,2>& reference){
blitz::Array<double,2> shifted(reference.shape());
self.shift_phase(jet, reference, shifted);
return shifted;
}
// re-definition of function so that they can be distinguished
static blitz::TinyVector<double,2> (bob::machine::GaborJetSimilarity::*disparity1)() const = &bob::machine::GaborJetSimilarity::disparity;
static blitz::TinyVector<double,2> (bob::machine::GaborJetSimilarity::*disparity2)(const blitz::Array<double,2>&, const blitz::Array<double,2>&) const = &bob::machine::GaborJetSimilarity::disparity;
void bind_machine_gabor(){
/////////////////////////////////////////////////////////////////////////////////////////
//////////////// Gabor jet similarities
boost::python::class_<bob::machine::GaborJetSimilarity, boost::noncopyable >(
"GaborJetSimilarity",
"This is the pure virtual base class for all Gabor jet similarities.",
boost::python::no_init
)
.def(
boost::python::init<bob::machine::GaborJetSimilarity::SimilarityType, const bob::ip::GaborWaveletTransform&>(
(
boost::python::arg("self"),
boost::python::arg("type"),
boost::python::arg("gwt") = bob::ip::GaborWaveletTransform()
),
"Generates a Gabor jet similarity measure of the given type. The parameters of the given transform are used for disparity-like similarity functions only."
)
)
.def(
"save",
&bob::machine::GaborJetSimilarity::save,
(boost::python::arg("self"), boost::python::arg("config")),
"Saves the parameterization of this Gabor jet similarity function to HDF5 file."
)
.def(
"load",
&bob::machine::GaborJetSimilarity::load,
(boost::python::arg("self"), boost::python::arg("config")),
"Loads the parameterization of this Gabor jet similarity function from HDF5 file."
)
.def(
"disparity",
disparity1,
(boost::python::arg("self")),
"Returns the disparity computed by the latest call. Only valid for disparity-like similarity function types."
)
.def(
"disparity",
disparity2,
(boost::python::arg("self"), boost::python::arg("jet1"), boost::python::arg("jet2")),
"Computes the disparity vector between the two Gabor jets. Assure that the correct GaborWaveletTransform class have been specified in the constructor."
)
.def(
"shift_phase",
bob_jet_shift_phase,
(boost::python::arg("self"), boost::python::arg("jet"), boost::python::arg("reference")),
"Returns a copy of jet, where the phases are shifted towards the reference Gabor jet."
)
.def(
"__call__",
&bob_jet_sim,
(boost::python::arg("self"), boost::python::arg("jet1"), boost::python::arg("jet2")),
"Computes the similarity between the given Gabor jets."
);
boost::python::enum_<bob::machine::GaborJetSimilarity::SimilarityType>("gabor_jet_similarity_type")
.value("SCALAR_PRODUCT", bob::machine::GaborJetSimilarity::SCALAR_PRODUCT)
.value("CANBERRA", bob::machine::GaborJetSimilarity::CANBERRA)
.value("DISPARITY", bob::machine::GaborJetSimilarity::DISPARITY)
.value("PHASE_DIFF", bob::machine::GaborJetSimilarity::PHASE_DIFF)
.value("PHASE_DIFF_PLUS_CANBERRA", bob::machine::GaborJetSimilarity::PHASE_DIFF_PLUS_CANBERRA)
.export_values();
/////////////////////////////////////////////////////////////////////////////////////////
//////////////// Gabor graph machine
boost::python::class_<bob::machine::GaborGraphMachine, boost::shared_ptr<bob::machine::GaborGraphMachine> >(
"GaborGraphMachine",
"This class implements functionality dealing with Gabor graphs, Gabor graph comparison and Gabor graph averaging.",
boost::python::no_init
)
.def(
boost::python::init<>(
boost::python::arg("self"),
"Generates an empty Grid graph extractor. This extractor should only be used to compute average graphs or to compare two graphs!"
)
)
.def(
boost::python::init<const bob::machine::GaborGraphMachine&>(
(boost::python::arg("self"), boost::python::arg("other")),
"Constructs a GaborGraphMachine from the one by doing a deep copy."
)
)
.def(
boost::python::self == boost::python::self
)
.def(
boost::python::init<blitz::TinyVector<int,2>, blitz::TinyVector<int,2>, int, int, int, int>(
(boost::python::arg("self"), boost::python::arg("lefteye"), boost::python::arg("righteye"), boost::python::arg("between")=3, boost::python::arg("along")=2, boost::python::arg("above")=4, boost::python::arg("below")=6),
"Generates a Grid graph extractor with nodes put according to the given eye positions, and the given number of nodes between, along, above, and below the eyes."
)
)
.def(
boost::python::init<blitz::TinyVector<int,2>, blitz::TinyVector<int,2>, blitz::TinyVector<int,2> >(
(boost::python::arg("self"), boost::python::arg("first"), boost::python::arg("last"), boost::python::arg("step")),
"Generates a Grid graph extractor with nodes put between the given first and last position in the desired step size."
)
)
.def(
"save",
&bob::machine::GaborGraphMachine::save,
(boost::python::arg("self"), boost::python::arg("config")),
"Saves the parameterization of this Gabor graph extractor to HDF5 file."
)
.def(
"load",
&bob::machine::GaborGraphMachine::load,
(boost::python::arg("self"), boost::python::arg("config")),
"Loads the parameterization of this Gabor graph extractor from HDF5 file."
)
.add_property(
"number_of_nodes",
&bob::machine::GaborGraphMachine::numberOfNodes,
"The number of nodes of the graph."
)
.add_property(
"nodes",
&bob::machine::GaborGraphMachine::nodes,
"The node positions of the graph."
)
.def(
"__call__",
&bob_extract,
(boost::python::arg("self"), boost::python::arg("jet_image"), boost::python::arg("graph_jets")),
"Extracts the Gabor jets at the desired locations from the given Gabor jet image"
)
.def(
"__call__",
&bob_extract2,
(boost::python::arg("self"), boost::python::arg("jet_image")),
"Extracts and returns the Gabor jets at the desired locations from the given Gabor jet image"
)
.def(
"average",
&bob_average,
(boost::python::arg("self"), boost::python::arg("many_graph_jets"), boost::python::arg("averaged_graph_jets")),
"Averages the given list of Gabor graphs into one Gabor graph"
)
.def(
"similarity",
&bob_similarity,
(boost::python::arg("self"), boost::python::arg("model_graph_jets"), boost::python::arg("probe_graph_jets"), boost::python::arg("jet_similarity_function")),
"Computes the similarity between the given probe graph and the gallery, which might be a single graph or a collection of graphs"
);
}
setup.py
+ 0
− 2
View file @ 17361082
......@@ -56,7 +56,6 @@ setup(
"bob/learn/misc/bic.cpp",
"bob/learn/misc/bic_trainer.cpp",
"bob/learn/misc/empca_trainer.cpp",
"bob/learn/misc/gabor.cpp",
"bob/learn/misc/gaussian.cpp",
"bob/learn/misc/gmm.cpp",
"bob/learn/misc/gmm_trainer.cpp",
......@@ -75,7 +74,6 @@ setup(
"bob/learn/misc/ztnorm.cpp",
# external requirements as boost::python bindings
"bob/learn/misc/GaborWaveletTransform.cpp",
"bob/learn/misc/blitz_numpy.cpp",
"bob/learn/misc/ndarray.cpp",
"bob/learn/misc/ndarray_numpy.cpp",
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment