Class: OpenCV::Std::Vector::Cv_Mat

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

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.vector ⇒ Object .vector ⇒ Object

Overloads:

Raises:

  • (ArgumentError) 


80552
80553
80554
80555
80556
80557
80558
80559
80560
80561
80562
80563
80564
80565
80566
80567
80568
80569
80570
80571
80572
80573
80574
80575
80576
80577
80578
80579
80580
80581
80582
80583
80584
80585
80586
 
# File 'lib/ropencv/ropencv_types.rb', line 80552

def self.new(*args)
    if args.first.is_a?(FFI::Pointer) || args.first.is_a?(Vector::Cv_MatStruct)
        raise ArgumentError, "too many arguments for creating #{self.name} from Pointer" unless args.size == 1
        return super(args.first)
    end
    # overloaded method wrapper for std::vector<cv::Mat>::vector<cv::Mat>()
    @@std_vector_cv_mat_vector_cv_mat_defaults0 ||= []
    if(args.size >= 0 && args.size <= 0)
        targs = args.clone
        targs.size.upto(-1) do |i|
            targs[i] = @@std_vector_cv_mat_vector_cv_mat_defaults0[i]
        end
        begin
                return Rbind::std_vector_cv_mat_vector_cv_mat(*targs)
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method wrapper for std::vector<cv::Mat>::vector<cv::Mat>(std::vector<cv::Mat> other)
    @@std_vector_cv_mat_vector_cv_mat__2_defaults1 ||= [nil]
    if(args.size >= 1 && args.size <= 1)
        targs = args.clone
        targs.size.upto(0) do |i|
            targs[i] = @@std_vector_cv_mat_vector_cv_mat__2_defaults1[i]
        end
        begin
                return Rbind::std_vector_cv_mat_vector_cv_mat__2(*targs)
        rescue TypeError => e
            @error = e
        end
    end

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

.null ⇒ Object

returns a null pointer to the object



80544
80545
80546
 
# File 'lib/ropencv/ropencv_types.rb', line 80544

def self.null
    new(Vector::Cv_MatStruct.new)
end

Instance Method Details

#<<(val) ⇒ Object 



80813
80814
80815
80816
 
# File 'lib/ropencv/ropencv_types.rb', line 80813

def <<(val)
    push_back(val)
    self
end

#[](idx) ⇒ Cv::Mat

Note:

method wrapper for cv::Mat std::vectorcv::Mat::operator

Parameters:

  • size (Size_T)

Returns:



80709
80710
80711
80712
80713
80714
80715
80716
80717
80718
 
# File 'lib/ropencv/ropencv_types.rb', line 80709

def [](size)
validate_index(size)
    __validate_pointer__
    result = Rbind::std_vector_cv_mat_operator_array( self, size)
    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

#at(size) ⇒ Cv::Mat

Note:

method wrapper for cv::Mat std::vectorcv::Mat::at(size_t size)

Parameters:

  • size (Size_T)

Returns:



80723
80724
80725
80726
80727
80728
80729
80730
80731
80732
 
# File 'lib/ropencv/ropencv_types.rb', line 80723

def at(size)
validate_index(size)
    __validate_pointer__
    result = Rbind::std_vector_cv_mat_at( self, size)
    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

#back ⇒ Cv::Mat

Note:

method wrapper for cv::Mat std::vectorcv::Mat::back()

Returns:



80748
80749
80750
80751
80752
80753
80754
80755
80756
 
# File 'lib/ropencv/ropencv_types.rb', line 80748

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

#capacity ⇒ Size_T

Note:

method wrapper for size_t std::vectorcv::Mat::capacity()

Returns:

  • (Size_T) 


80686
80687
80688
80689
 
# File 'lib/ropencv/ropencv_types.rb', line 80686

def capacity()
    __validate_pointer__
    Rbind::std_vector_cv_mat_capacity( self)
end

#clear ⇒ Void

Note:

method wrapper for void std::vectorcv::Mat::clear()

Returns:

  • (Void) 


80679
80680
80681
80682
 
# File 'lib/ropencv/ropencv_types.rb', line 80679

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

#data ⇒ Void

Note:

method wrapper for void* std::vectorcv::Mat::data()

Returns:

  • (Void) 


80760
80761
80762
80763
 
# File 'lib/ropencv/ropencv_types.rb', line 80760

def data()
    __validate_pointer__
    Rbind::std_vector_cv_mat_data( self)
end

#delete_if(&block) ⇒ Object 



80817
80818
80819
80820
80821
80822
80823
80824
 
# File 'lib/ropencv/ropencv_types.rb', line 80817

def delete_if(&block)
    v = self.class.new
    each do |i|
         v << i if !yield(i)
    end
    v.swap(self)
    self
end

#each(&block) ⇒ Object 



80803
80804
80805
80806
80807
80808
80809
80810
80811
80812
 
# File 'lib/ropencv/ropencv_types.rb', line 80803

def each(&block)
    if block
         s = size
         0.upto(s-1) do |i|
             yield self[i]
         end
    else
        Enumerator.new(self)
    end
end

#empty ⇒ Bool

Note:

method wrapper for bool std::vectorcv::Mat::empty()

Returns:

  • (Bool) 


80693
80694
80695
80696
 
# File 'lib/ropencv/ropencv_types.rb', line 80693

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

#front ⇒ Cv::Mat

Note:

method wrapper for cv::Mat std::vectorcv::Mat::front()

Returns:



80736
80737
80738
80739
80740
80741
80742
80743
80744
 
# File 'lib/ropencv/ropencv_types.rb', line 80736

def front()
    __validate_pointer__
    result = Rbind::std_vector_cv_mat_front( 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_element ⇒ Cv::Mat

Note:

method wrapper for cv::Mat std::vectorcv::Mat::operator

Parameters:

  • size (Size_T)

Returns:



80792
80793
80794
80795
80796
80797
80798
80799
80800
80801
 
# File 'lib/ropencv/ropencv_types.rb', line 80792

def [](size)
validate_index(size)
    __validate_pointer__
    result = Rbind::std_vector_cv_mat_operator_array( self, size)
    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

#pop_back ⇒ Void

Note:

method wrapper for void std::vectorcv::Mat::pop_back()

Returns:

  • (Void) 


80775
80776
80777
80778
 
# File 'lib/ropencv/ropencv_types.rb', line 80775

def pop_back()
    __validate_pointer__
    Rbind::std_vector_cv_mat_pop_back( self)
end

#push_back(other) ⇒ Void

Note:

method wrapper for void std::vectorcv::Mat::push_back(cv::Mat other)

Parameters:

Returns:

  • (Void) 


80768
80769
80770
80771
 
# File 'lib/ropencv/ropencv_types.rb', line 80768

def push_back(other)
    __validate_pointer__
    Rbind::std_vector_cv_mat_push_back( self, other)
end

#reserve(size) ⇒ Void

Note:

method wrapper for void std::vectorcv::Mat::reserve(size_t size)

Parameters:

  • size (Size_T)

Returns:

  • (Void) 


80701
80702
80703
80704
 
# File 'lib/ropencv/ropencv_types.rb', line 80701

def reserve(size)
    __validate_pointer__
    Rbind::std_vector_cv_mat_reserve( self, size)
end

#resize(size, val = Cv::Mat.new()) ⇒ Void

Note:

method wrapper for void std::vectorcv::Mat::resize(size_t size, cv::Mat val = cv::Mat())

methods

Parameters:

  • size (Size_T)
  • val (Cv::Mat) (defaults to: Cv::Mat.new())

Returns:

  • (Void) 


80665
80666
80667
80668
 
# File 'lib/ropencv/ropencv_types.rb', line 80665

def resize(size, val = Cv::Mat.new())
    __validate_pointer__
    Rbind::std_vector_cv_mat_resize( self, size, val)
end

#size ⇒ Size_T

Note:

method wrapper for size_t std::vectorcv::Mat::size()

Returns:

  • (Size_T) 


80672
80673
80674
80675
 
# File 'lib/ropencv/ropencv_types.rb', line 80672

def size()
    __validate_pointer__
    Rbind::std_vector_cv_mat_size( self)
end

#swap(other) ⇒ Void

Note:

method wrapper for void std::vectorcv::Mat::swap(std::vectorcv::Mat other)

Parameters:

Returns:

  • (Void) 


80783
80784
80785
80786
 
# File 'lib/ropencv/ropencv_types.rb', line 80783

def swap(other)
    __validate_pointer__
    Rbind::std_vector_cv_mat_swap( self, other)
end

#to_s ⇒ Object

converts Vector::Cv_Mat into a string by crawling through all its attributes



80652
80653
80654
 
# File 'lib/ropencv/ropencv_types.rb', line 80652

def to_s
    "#<std::vector<cv::Mat> >"
end

#validate_index(idx) ⇒ Object 



80798
80799
80800
80801
80802
 
# File 'lib/ropencv/ropencv_types.rb', line 80798

def validate_index(idx)
    if idx < 0 || idx >= size
        raise RangeError,"#{idx} is out of range [0..#{size-1}]"
    end
end