Class: OpenCV::Cv::SimpleBlobDetector

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

Defined Under Namespace

Classes: Params

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.create(parameters = Cv::SimpleBlobDetector::Params.new()) ⇒ Cv::Ptr::Cv_SimpleBlobDetector

Note:

wrapper for static method const cv::Ptrcv::SimpleBlobDetector cv::SimpleBlobDetector::create(const cv::SimpleBlobDetector::Params parameters = SimpleBlobDetector::Params())

methods

Parameters:

Returns:



62139
62140
62141
 
# File 'lib/ropencv/ropencv_types.rb', line 62139

def self.create(parameters = Cv::SimpleBlobDetector::Params.new())
    Rbind::cv_simple_blob_detector_create(parameters)
end

.new(*args) ⇒ Object

Raises:

  • (ArgumentError) 


62054
62055
62056
62057
62058
62059
62060
62061
 
# File 'lib/ropencv/ropencv_types.rb', line 62054

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



62050
62051
62052
 
# File 'lib/ropencv/ropencv_types.rb', line 62050

def self.null
    new(SimpleBlobDetectorStruct.new)
end

Instance Method Details

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

Note:

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

Parameters:

  • parse_ownership (Bool)

Returns:



62390
62391
62392
62393
62394
62395
62396
62397
62398
 
# File 'lib/ropencv/ropencv_types.rb', line 62390

def cast_to_algorithm(parse_ownership)
    __validate_pointer__
    result = Rbind::cv_simple_blob_detector_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::SimpleBlobDetector::castToFeature2D(bool parse_ownership)

Parameters:

  • parse_ownership (Bool)

Returns:



62159
62160
62161
62162
62163
62164
62165
62166
62167
 
# File 'lib/ropencv/ropencv_types.rb', line 62159

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

Returns:

  • (Void) 


62403
62404
62405
62406
 
# File 'lib/ropencv/ropencv_types.rb', line 62403

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

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

Note:

wrapper for overloaded method compute

Overloads:

Raises:

  • (ArgumentError) 


62227
62228
62229
62230
62231
62232
62233
62234
62235
62236
62237
62238
62239
62240
62241
62242
62243
62244
62245
62246
62247
62248
62249
62250
62251
62252
62253
62254
62255
62256
62257
62258
 
# File 'lib/ropencv/ropencv_types.rb', line 62227

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

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

Returns:

  • (Fixnum) 


62291
62292
62293
62294
 
# File 'lib/ropencv/ropencv_types.rb', line 62291

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

#descriptor_size ⇒ Fixnum Also known as: descriptorSize

Note:

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

Returns:

  • (Fixnum) 


62275
62276
62277
62278
 
# File 'lib/ropencv/ropencv_types.rb', line 62275

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

#descriptor_type ⇒ Fixnum Also known as: descriptorType

Note:

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

Returns:

  • (Fixnum) 


62283
62284
62285
62286
 
# File 'lib/ropencv/ropencv_types.rb', line 62283

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


62182
62183
62184
62185
62186
62187
62188
62189
62190
62191
62192
62193
62194
62195
62196
62197
62198
62199
62200
62201
62202
62203
62204
62205
62206
62207
62208
62209
62210
62211
62212
62213
 
# File 'lib/ropencv/ropencv_types.rb', line 62182

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

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

Parameters:

Returns:

  • (Void) 


62267
62268
62269
62270
 
# File 'lib/ropencv/ropencv_types.rb', line 62267

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

#empty ⇒ Bool

Note:

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

Returns:

  • (Bool) 


62382
62383
62384
62385
 
# File 'lib/ropencv/ropencv_types.rb', line 62382

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

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

Note:

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

Returns:



62145
62146
62147
62148
62149
62150
62151
62152
62153
 
# File 'lib/ropencv/ropencv_types.rb', line 62145

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


62347
62348
62349
62350
62351
62352
62353
62354
62355
62356
62357
62358
62359
62360
62361
62362
62363
62364
62365
62366
62367
62368
62369
62370
62371
62372
62373
62374
62375
62376
62377
62378
 
# File 'lib/ropencv/ropencv_types.rb', line 62347

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

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

Parameters:

Returns:

  • (Void) 


62411
62412
62413
62414
 
# File 'lib/ropencv/ropencv_types.rb', line 62411

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

#to_s ⇒ Object

converts SimpleBlobDetector into a string by crawling through all its attributes



62127
62128
62129
 
# File 'lib/ropencv/ropencv_types.rb', line 62127

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


62306
62307
62308
62309
62310
62311
62312
62313
62314
62315
62316
62317
62318
62319
62320
62321
62322
62323
62324
62325
62326
62327
62328
62329
62330
62331
62332
62333
62334
62335
62336
62337
 
# File 'lib/ropencv/ropencv_types.rb', line 62306

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

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

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