Class: OpenCV::Cv::Feature2D

Inherits:
Object
  • Object
show all
Extended by:
FFI::DataConverter
Defined in:
lib/ropencv/ropencv_types.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.cast_from_algorithm(ptr, parse_ownership) ⇒ Cv::Feature2D Also known as: castFromAlgorithm

Note:

wrapper for static method cv::Feature2D* cv::Feature2D::castFromAlgorithm(cv::Algorithm* ptr, bool parse_ownership)

Parameters:

Returns:



10259
10260
10261
 
# File 'lib/ropencv/ropencv_types.rb', line 10259

def self.cast_from_algorithm(ptr, parse_ownership)
    Rbind::cv_feature2d_cast_from_algorithm(ptr, parse_ownership)
end

.new(*args) ⇒ Object

Raises:

  • (ArgumentError) 


9929
9930
9931
9932
9933
9934
9935
9936
 
# File 'lib/ropencv/ropencv_types.rb', line 9929

def self.new(*args)
    if args.first.is_a?(FFI::Pointer) || args.first.is_a?(Feature2DStruct)
        raise ArgumentError, "too many arguments for creating #{self.name} from Pointer" unless args.size == 1
        return super(args.first)
    end

    raise ArgumentError, "no constructor for #{self}(#{args.inspect})"
end

.null ⇒ Object

returns a null pointer to the object



9925
9926
9927
 
# File 'lib/ropencv/ropencv_types.rb', line 9925

def self.null
    new(Feature2DStruct.new)
end

Instance Method Details

#cast_to_algorithm(parse_ownership) ⇒ Cv::Algorithm Also known as: castToAlgorithm

Note:

method wrapper for cv::Algorithm* cv::Feature2D::castToAlgorithm(bool parse_ownership)

Parameters:

  • parse_ownership (Bool)

Returns:



10244
10245
10246
10247
10248
10249
10250
10251
10252
 
# File 'lib/ropencv/ropencv_types.rb', line 10244

def cast_to_algorithm(parse_ownership)
    __validate_pointer__
    result = Rbind::cv_feature2d_cast_to_algorithm( self, parse_ownership)
    if result.respond_to?(:__owner__?) && !result.__owner__?
    # store owner insight the pointer to not get garbage collected
        result.instance_variable_get(:@__obj_ptr__).instance_variable_set(:@__owner__,self) 
    end
    result
end

#clear ⇒ Void

Note:

method wrapper for void cv::Feature2D::clear()

Returns:

  • (Void) 


10266
10267
10268
10269
 
# File 'lib/ropencv/ropencv_types.rb', line 10266

def clear()
    __validate_pointer__
    Rbind::cv_feature2d_clear( self)
end

#compute(image, keypoints, descriptors) ⇒ Void #compute(images, keypoints, descriptors) ⇒ Void

Note:

wrapper for overloaded method compute

Overloads:

Raises:

  • (ArgumentError) 


10068
10069
10070
10071
10072
10073
10074
10075
10076
10077
10078
10079
10080
10081
10082
10083
10084
10085
10086
10087
10088
10089
10090
10091
10092
10093
10094
10095
10096
10097
10098
10099
 
# File 'lib/ropencv/ropencv_types.rb', line 10068

def compute(*args)
    __validate_pointer__
    # overloaded method wrapper for void cv::Feature2D::compute(const cv::Mat image, std::vector<cv::KeyPoint>& keypoints, cv::Mat& descriptors)
    @@cv_feature2d_compute_defaults0 ||= [nil, nil, nil]
    if(args.size >= 3 && args.size <= 3)
        targs = args.clone
        targs.size.upto(2) do |i|
            targs[i] = @@cv_feature2d_compute_defaults0[i]
        end
        begin
                return Rbind::cv_feature2d_compute(self,*targs)
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method wrapper for void cv::Feature2D::compute(const std::vector<cv::Mat> images, std::vector<std::vector<cv::KeyPoint> >& keypoints, std::vector<cv::Mat>& descriptors)
    @@cv_feature2d_compute__2_defaults1 ||= [nil, nil, nil]
    if(args.size >= 3 && args.size <= 3)
        targs = args.clone
        targs.size.upto(2) do |i|
            targs[i] = @@cv_feature2d_compute__2_defaults1[i]
        end
        begin
                return Rbind::cv_feature2d_compute__2(self,*targs)
        rescue TypeError => e
            @error = e
        end
    end

    raise ArgumentError, "No overloaded signature fits to: #{args.map(&:class)}"
end

#default_norm ⇒ Fixnum Also known as: defaultNorm

Note:

method wrapper for int cv::Feature2D::defaultNorm()

Returns:

  • (Fixnum) 


10132
10133
10134
10135
 
# File 'lib/ropencv/ropencv_types.rb', line 10132

def default_norm()
    __validate_pointer__
    Rbind::cv_feature2d_default_norm( self)
end

#descriptor_size ⇒ Fixnum Also known as: descriptorSize

Note:

method wrapper for int cv::Feature2D::descriptorSize()

Returns:

  • (Fixnum) 


10116
10117
10118
10119
 
# File 'lib/ropencv/ropencv_types.rb', line 10116

def descriptor_size()
    __validate_pointer__
    Rbind::cv_feature2d_descriptor_size( self)
end

#descriptor_type ⇒ Fixnum Also known as: descriptorType

Note:

method wrapper for int cv::Feature2D::descriptorType()

Returns:

  • (Fixnum) 


10124
10125
10126
10127
 
# File 'lib/ropencv/ropencv_types.rb', line 10124

def descriptor_type()
    __validate_pointer__
    Rbind::cv_feature2d_descriptor_type( self)
end

#detect(image, keypoints, mask = Cv::Mat.new()) ⇒ Void #detect(images, keypoints, masks = Std::Vector::Cv_Mat.new()) ⇒ Void

Note:

wrapper for overloaded method detect

methods

Overloads:

Raises:

  • (ArgumentError) 


10023
10024
10025
10026
10027
10028
10029
10030
10031
10032
10033
10034
10035
10036
10037
10038
10039
10040
10041
10042
10043
10044
10045
10046
10047
10048
10049
10050
10051
10052
10053
10054
 
# File 'lib/ropencv/ropencv_types.rb', line 10023

def detect(*args)
    __validate_pointer__
    # overloaded method wrapper for void cv::Feature2D::detect(const cv::Mat image, std::vector<cv::KeyPoint>& keypoints, const cv::Mat mask = Mat())
    @@cv_feature2d_detect_defaults0 ||= [nil, nil, Cv::Mat.new()]
    if(args.size >= 2 && args.size <= 3)
        targs = args.clone
        targs.size.upto(2) do |i|
            targs[i] = @@cv_feature2d_detect_defaults0[i]
        end
        begin
                return Rbind::cv_feature2d_detect(self,*targs)
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method wrapper for void cv::Feature2D::detect(const std::vector<cv::Mat> images, std::vector<std::vector<cv::KeyPoint> >& keypoints, const std::vector<cv::Mat> masks = vector<Mat>())
    @@cv_feature2d_detect__2_defaults1 ||= [nil, nil, Std::Vector::Cv_Mat.new()]
    if(args.size >= 2 && args.size <= 3)
        targs = args.clone
        targs.size.upto(2) do |i|
            targs[i] = @@cv_feature2d_detect__2_defaults1[i]
        end
        begin
                return Rbind::cv_feature2d_detect__2(self,*targs)
        rescue TypeError => e
            @error = e
        end
    end

    raise ArgumentError, "No overloaded signature fits to: #{args.map(&:class)}"
end

#detect_and_compute(image, mask, keypoints, descriptors, use_provided_keypoints = false) ⇒ Void Also known as: detectAndCompute

Note:

method wrapper for void cv::Feature2D::detectAndCompute(const cv::Mat image, const cv::Mat mask, std::vectorcv::KeyPoint& keypoints, cv::Mat& descriptors, bool useProvidedKeypoints = false)

Parameters:

Returns:

  • (Void) 


10108
10109
10110
10111
 
# File 'lib/ropencv/ropencv_types.rb', line 10108

def detect_and_compute(image, mask, keypoints, descriptors, use_provided_keypoints = false)
    __validate_pointer__
    Rbind::cv_feature2d_detect_and_compute( self, image, mask, keypoints, descriptors, use_provided_keypoints)
end

#empty ⇒ Bool

Note:

method wrapper for bool cv::Feature2D::empty()

Returns:

  • (Bool) 


10223
10224
10225
10226
 
# File 'lib/ropencv/ropencv_types.rb', line 10223

def empty()
    __validate_pointer__
    Rbind::cv_feature2d_empty( self)
end

#get_default_name ⇒ Std::String Also known as: getDefaultName

Note:

method wrapper for const std::string cv::Feature2D::getDefaultName()

Returns:



10230
10231
10232
10233
10234
10235
10236
10237
10238
 
# File 'lib/ropencv/ropencv_types.rb', line 10230

def get_default_name()
    __validate_pointer__
    result = Rbind::cv_feature2d_get_default_name( self)
    if result.respond_to?(:__owner__?) && !result.__owner__?
    # store owner insight the pointer to not get garbage collected
        result.instance_variable_get(:@__obj_ptr__).instance_variable_set(:@__owner__,self) 
    end
    result
end

#read(file_name) ⇒ Void #read(_arg1) ⇒ Void

Note:

wrapper for overloaded method read

Overloads:

  • #read(file_name) ⇒ Void

    Parameters:

    Returns:

    • (Void)
  • #read(_arg1) ⇒ Void

    Parameters:

    Returns:

    • (Void)

Raises:

  • (ArgumentError) 


10188
10189
10190
10191
10192
10193
10194
10195
10196
10197
10198
10199
10200
10201
10202
10203
10204
10205
10206
10207
10208
10209
10210
10211
10212
10213
10214
10215
10216
10217
10218
10219
 
# File 'lib/ropencv/ropencv_types.rb', line 10188

def read(*args)
    __validate_pointer__
    # overloaded method wrapper for void cv::Feature2D::read(const std::string fileName)
    @@cv_feature2d_read_defaults0 ||= [nil]
    if(args.size >= 1 && args.size <= 1)
        targs = args.clone
        targs.size.upto(0) do |i|
            targs[i] = @@cv_feature2d_read_defaults0[i]
        end
        begin
                return Rbind::cv_feature2d_read(self,*targs)
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method wrapper for void cv::Feature2D::read(const cv::FileNode arg1)
    @@cv_feature2d_read__2_defaults1 ||= [nil]
    if(args.size >= 1 && args.size <= 1)
        targs = args.clone
        targs.size.upto(0) do |i|
            targs[i] = @@cv_feature2d_read__2_defaults1[i]
        end
        begin
                return Rbind::cv_feature2d_read__2(self,*targs)
        rescue TypeError => e
            @error = e
        end
    end

    raise ArgumentError, "No overloaded signature fits to: #{args.map(&:class)}"
end

#save(filename) ⇒ Void

Note:

method wrapper for void cv::Feature2D::save(const std::string filename)

Parameters:

Returns:

  • (Void) 


10274
10275
10276
10277
 
# File 'lib/ropencv/ropencv_types.rb', line 10274

def save(filename)
    __validate_pointer__
    Rbind::cv_feature2d_save( self, filename)
end

#to_s ⇒ Object

converts Feature2D into a string by crawling through all its attributes



10002
10003
10004
 
# File 'lib/ropencv/ropencv_types.rb', line 10002

def to_s
    "#<cv::Feature2D >"
end

#write(file_name) ⇒ Void #write(fs, name = Std::String.new()) ⇒ Void

Note:

wrapper for overloaded method write

Overloads:

  • #write(file_name) ⇒ Void

    Parameters:

    Returns:

    • (Void)
  • #write(fs, name = Std::String.new()) ⇒ Void

    Parameters:

    Returns:

    • (Void)

Raises:

  • (ArgumentError) 


10147
10148
10149
10150
10151
10152
10153
10154
10155
10156
10157
10158
10159
10160
10161
10162
10163
10164
10165
10166
10167
10168
10169
10170
10171
10172
10173
10174
10175
10176
10177
10178
 
# File 'lib/ropencv/ropencv_types.rb', line 10147

def write(*args)
    __validate_pointer__
    # overloaded method wrapper for void cv::Feature2D::write(const std::string fileName)
    @@cv_feature2d_write_defaults0 ||= [nil]
    if(args.size >= 1 && args.size <= 1)
        targs = args.clone
        targs.size.upto(0) do |i|
            targs[i] = @@cv_feature2d_write_defaults0[i]
        end
        begin
                return Rbind::cv_feature2d_write(self,*targs)
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method wrapper for void cv::Feature2D::write(const cv::Ptr<cv::FileStorage> fs, const std::string name = String())
    @@cv_feature2d_write__2_defaults1 ||= [nil, Std::String.new()]
    if(args.size >= 1 && args.size <= 2)
        targs = args.clone
        targs.size.upto(1) do |i|
            targs[i] = @@cv_feature2d_write__2_defaults1[i]
        end
        begin
                return Rbind::cv_feature2d_write__2(self,*targs)
        rescue TypeError => e
            @error = e
        end
    end

    raise ArgumentError, "No overloaded signature fits to: #{args.map(&:class)}"
end