Class: OpenCV::Cv::BRISK

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

.create(thresh = 30, octaves = 3, pattern_scale = 1.0) ⇒ Cv::Ptr::Cv_BRISK .create(radius_list, number_list, d_max = 5.85, d_min = 8.2, index_change = Std::Vector::Int.new()) ⇒ Cv::Ptr::Cv_BRISK .create(thresh, octaves, radius_list, number_list, d_max = 5.85, d_min = 8.2, index_change = Std::Vector::Int.new()) ⇒ Cv::Ptr::Cv_BRISK

Note:

wrapper for overloaded static method create

methods

Overloads:

Raises:

  • (ArgumentError) 


57540
57541
57542
57543
57544
57545
57546
57547
57548
57549
57550
57551
57552
57553
57554
57555
57556
57557
57558
57559
57560
57561
57562
57563
57564
57565
57566
57567
57568
57569
57570
57571
57572
57573
57574
57575
57576
57577
57578
57579
57580
57581
57582
57583
57584
57585
57586
57587
57588
57589
57590
57591
57592
57593
 
# File 'lib/ropencv/ropencv_types.rb', line 57540

def self.create(*args)
    # overloaded method wrapper for const cv::Ptr<cv::BRISK> cv::BRISK::create(int thresh = 30, int octaves = 3, float patternScale = 1.0f)
    @@cv_brisk_create_defaults0 ||= [30, 3, 1.0]
    if(args.size >= 0 && args.size <= 3)
        targs = args.clone
        targs.size.upto(2) do |i|
            targs[i] = @@cv_brisk_create_defaults0[i]
        end
        begin
                result = Rbind::cv_brisk_create(*targs)
            # store owner insight the pointer to not get garbage collected
            result.instance_variable_get(:@__obj_ptr__).instance_variable_set(:@__owner__,self) if !result.__owner__?
            return result
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method wrapper for const cv::Ptr<cv::BRISK> cv::BRISK::create(const std::vector<float> radiusList, const std::vector<int> numberList, float dMax = 5.85f, float dMin = 8.2f, const std::vector<int> indexChange = std::vector<int>())
    @@cv_brisk_create__2_defaults1 ||= [nil, nil, 5.85, 8.2, Std::Vector::Int.new()]
    if(args.size >= 2 && args.size <= 5)
        targs = args.clone
        targs.size.upto(4) do |i|
            targs[i] = @@cv_brisk_create__2_defaults1[i]
        end
        begin
                result = Rbind::cv_brisk_create__2(*targs)
            # store owner insight the pointer to not get garbage collected
            result.instance_variable_get(:@__obj_ptr__).instance_variable_set(:@__owner__,self) if !result.__owner__?
            return result
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method wrapper for const cv::Ptr<cv::BRISK> cv::BRISK::create(int thresh, int octaves, const std::vector<float> radiusList, const std::vector<int> numberList, float dMax = 5.85f, float dMin = 8.2f, const std::vector<int> indexChange = std::vector<int>())
    @@cv_brisk_create__3_defaults2 ||= [nil, nil, nil, nil, 5.85, 8.2, Std::Vector::Int.new()]
    if(args.size >= 4 && args.size <= 7)
        targs = args.clone
        targs.size.upto(6) do |i|
            targs[i] = @@cv_brisk_create__3_defaults2[i]
        end
        begin
                result = Rbind::cv_brisk_create__3(*targs)
            # store owner insight the pointer to not get garbage collected
            result.instance_variable_get(:@__obj_ptr__).instance_variable_set(:@__owner__,self) if !result.__owner__?
            return result
        rescue TypeError => e
            @error = e
        end
    end

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

.new(*args) ⇒ Object

Raises:

  • (ArgumentError) 


57434
57435
57436
57437
57438
57439
57440
57441
 
# File 'lib/ropencv/ropencv_types.rb', line 57434

def self.new(*args)
    if args.first.is_a?(FFI::Pointer) || args.first.is_a?(BRISKStruct)
        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



57430
57431
57432
 
# File 'lib/ropencv/ropencv_types.rb', line 57430

def self.null
    new(BRISKStruct.new)
end

Instance Method Details

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

Note:

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

Parameters:

  • parse_ownership (Bool)

Returns:



57875
57876
57877
57878
57879
57880
57881
57882
57883
 
# File 'lib/ropencv/ropencv_types.rb', line 57875

def cast_to_algorithm(parse_ownership)
    __validate_pointer__
    result = Rbind::cv_brisk_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

#cast_to_feature2d(parse_ownership) ⇒ Cv::Feature2D Also known as: castToFeature2D

Note:

method wrapper for cv::Feature2D* cv::BRISK::castToFeature2D(bool parse_ownership)

Parameters:

  • parse_ownership (Bool)

Returns:



57644
57645
57646
57647
57648
57649
57650
57651
57652
 
# File 'lib/ropencv/ropencv_types.rb', line 57644

def cast_to_feature2d(parse_ownership)
    __validate_pointer__
    result = Rbind::cv_brisk_cast_to_feature2d( 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::BRISK::clear()

Returns:

  • (Void) 


57888
57889
57890
57891
 
# File 'lib/ropencv/ropencv_types.rb', line 57888

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

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

Note:

wrapper for overloaded method compute

Overloads:

Raises:

  • (ArgumentError) 


57712
57713
57714
57715
57716
57717
57718
57719
57720
57721
57722
57723
57724
57725
57726
57727
57728
57729
57730
57731
57732
57733
57734
57735
57736
57737
57738
57739
57740
57741
57742
57743
 
# File 'lib/ropencv/ropencv_types.rb', line 57712

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

    # overloaded method wrapper for void cv::BRISK::compute(const std::vector<cv::Mat> images, std::vector<std::vector<cv::KeyPoint> >& keypoints, std::vector<cv::Mat>& descriptors)
    @@cv_brisk_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_brisk_compute__2_defaults1[i]
        end
        begin
                return Rbind::cv_brisk_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::BRISK::defaultNorm()

Returns:

  • (Fixnum) 


57776
57777
57778
57779
 
# File 'lib/ropencv/ropencv_types.rb', line 57776

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

#descriptor_size ⇒ Fixnum Also known as: descriptorSize

Note:

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

Returns:

  • (Fixnum) 


57760
57761
57762
57763
 
# File 'lib/ropencv/ropencv_types.rb', line 57760

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

#descriptor_type ⇒ Fixnum Also known as: descriptorType

Note:

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

Returns:

  • (Fixnum) 


57768
57769
57770
57771
 
# File 'lib/ropencv/ropencv_types.rb', line 57768

def descriptor_type()
    __validate_pointer__
    Rbind::cv_brisk_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

Overloads:

Raises:

  • (ArgumentError) 


57667
57668
57669
57670
57671
57672
57673
57674
57675
57676
57677
57678
57679
57680
57681
57682
57683
57684
57685
57686
57687
57688
57689
57690
57691
57692
57693
57694
57695
57696
57697
57698
 
# File 'lib/ropencv/ropencv_types.rb', line 57667

def detect(*args)
    __validate_pointer__
    # overloaded method wrapper for void cv::BRISK::detect(const cv::Mat image, std::vector<cv::KeyPoint>& keypoints, const cv::Mat mask = Mat())
    @@cv_brisk_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_brisk_detect_defaults0[i]
        end
        begin
                return Rbind::cv_brisk_detect(self,*targs)
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method wrapper for void cv::BRISK::detect(const std::vector<cv::Mat> images, std::vector<std::vector<cv::KeyPoint> >& keypoints, const std::vector<cv::Mat> masks = vector<Mat>())
    @@cv_brisk_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_brisk_detect__2_defaults1[i]
        end
        begin
                return Rbind::cv_brisk_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::BRISK::detectAndCompute(const cv::Mat image, const cv::Mat mask, std::vectorcv::KeyPoint& keypoints, cv::Mat& descriptors, bool useProvidedKeypoints = false)

Parameters:

Returns:

  • (Void) 


57752
57753
57754
57755
 
# File 'lib/ropencv/ropencv_types.rb', line 57752

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

#empty ⇒ Bool

Note:

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

Returns:

  • (Bool) 


57867
57868
57869
57870
 
# File 'lib/ropencv/ropencv_types.rb', line 57867

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

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

Note:

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

Returns:



57596
57597
57598
57599
57600
57601
57602
57603
57604
 
# File 'lib/ropencv/ropencv_types.rb', line 57596

def get_default_name()
    __validate_pointer__
    result = Rbind::cv_brisk_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

#get_octaves ⇒ Fixnum Also known as: getOctaves

Note:

method wrapper for int cv::BRISK::getOctaves()

Returns:

  • (Fixnum) 


57635
57636
57637
57638
 
# File 'lib/ropencv/ropencv_types.rb', line 57635

def get_octaves()
    __validate_pointer__
    Rbind::cv_brisk_get_octaves( self)
end

#get_threshold ⇒ Fixnum Also known as: getThreshold

Note:

method wrapper for int cv::BRISK::getThreshold()

Returns:

  • (Fixnum) 


57618
57619
57620
57621
 
# File 'lib/ropencv/ropencv_types.rb', line 57618

def get_threshold()
    __validate_pointer__
    Rbind::cv_brisk_get_threshold( self)
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) 


57832
57833
57834
57835
57836
57837
57838
57839
57840
57841
57842
57843
57844
57845
57846
57847
57848
57849
57850
57851
57852
57853
57854
57855
57856
57857
57858
57859
57860
57861
57862
57863
 
# File 'lib/ropencv/ropencv_types.rb', line 57832

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

    # overloaded method wrapper for void cv::BRISK::read(const cv::FileNode arg1)
    @@cv_brisk_read__2_defaults1 ||= [nil]
    if(args.size >= 1 && args.size <= 1)
        targs = args.clone
        targs.size.upto(0) do |i|
            targs[i] = @@cv_brisk_read__2_defaults1[i]
        end
        begin
                return Rbind::cv_brisk_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::BRISK::save(const std::string filename)

Parameters:

Returns:

  • (Void) 


57896
57897
57898
57899
 
# File 'lib/ropencv/ropencv_types.rb', line 57896

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

#set_octaves(octaves) ⇒ Void Also known as: setOctaves

Note:

method wrapper for void cv::BRISK::setOctaves(int octaves)

Parameters:

  • octaves (Fixnum)

Returns:

  • (Void) 


57627
57628
57629
57630
 
# File 'lib/ropencv/ropencv_types.rb', line 57627

def set_octaves(octaves)
    __validate_pointer__
    Rbind::cv_brisk_set_octaves( self, octaves)
end

#set_threshold(threshold) ⇒ Void Also known as: setThreshold

Note:

method wrapper for void cv::BRISK::setThreshold(int threshold)

Parameters:

  • threshold (Fixnum)

Returns:

  • (Void) 


57610
57611
57612
57613
 
# File 'lib/ropencv/ropencv_types.rb', line 57610

def set_threshold(threshold)
    __validate_pointer__
    Rbind::cv_brisk_set_threshold( self, threshold)
end

#to_s ⇒ Object

converts BRISK into a string by crawling through all its attributes



57507
57508
57509
 
# File 'lib/ropencv/ropencv_types.rb', line 57507

def to_s
    "#<cv::BRISK >"
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) 


57791
57792
57793
57794
57795
57796
57797
57798
57799
57800
57801
57802
57803
57804
57805
57806
57807
57808
57809
57810
57811
57812
57813
57814
57815
57816
57817
57818
57819
57820
57821
57822
 
# File 'lib/ropencv/ropencv_types.rb', line 57791

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

    # overloaded method wrapper for void cv::BRISK::write(const cv::Ptr<cv::FileStorage> fs, const std::string name = String())
    @@cv_brisk_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_brisk_write__2_defaults1[i]
        end
        begin
                return Rbind::cv_brisk_write__2(self,*targs)
        rescue TypeError => e
            @error = e
        end
    end

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