Class: OpenCV::Std::Vector::Cv_Scalar

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

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.vector ⇒ Object .vector ⇒ Object

Overloads:

Raises:

  • (ArgumentError) 


88985
88986
88987
88988
88989
88990
88991
88992
88993
88994
88995
88996
88997
88998
88999
89000
89001
89002
89003
89004
89005
89006
89007
89008
89009
89010
89011
89012
89013
89014
89015
89016
89017
89018
89019
 
# File 'lib/ropencv/ropencv_types.rb', line 88985

def self.new(*args)
    if args.first.is_a?(FFI::Pointer) || args.first.is_a?(Vector::Cv_ScalarStruct)
        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::Scalar>::vector<cv::Scalar>()
    @@std_vector_cv_scalar_vector_cv_scalar_defaults0 ||= []
    if(args.size >= 0 && args.size <= 0)
        targs = args.clone
        targs.size.upto(-1) do |i|
            targs[i] = @@std_vector_cv_scalar_vector_cv_scalar_defaults0[i]
        end
        begin
                return Rbind::std_vector_cv_scalar_vector_cv_scalar(*targs)
        rescue TypeError => e
            @error = e
        end
    end

    # overloaded method wrapper for std::vector<cv::Scalar>::vector<cv::Scalar>(std::vector<cv::Scalar> other)
    @@std_vector_cv_scalar_vector_cv_scalar__2_defaults1 ||= [nil]
    if(args.size >= 1 && args.size <= 1)
        targs = args.clone
        targs.size.upto(0) do |i|
            targs[i] = @@std_vector_cv_scalar_vector_cv_scalar__2_defaults1[i]
        end
        begin
                return Rbind::std_vector_cv_scalar_vector_cv_scalar__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



88977
88978
88979
 
# File 'lib/ropencv/ropencv_types.rb', line 88977

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

Instance Method Details

#<<(val) ⇒ Object 



89246
89247
89248
89249
 
# File 'lib/ropencv/ropencv_types.rb', line 89246

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

#[](idx) ⇒ Cv::Scalar

Note:

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

Parameters:

  • size (Size_T)

Returns:



89142
89143
89144
89145
89146
89147
89148
89149
89150
89151
 
# File 'lib/ropencv/ropencv_types.rb', line 89142

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

Note:

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

Parameters:

  • size (Size_T)

Returns:



89156
89157
89158
89159
89160
89161
89162
89163
89164
89165
 
# File 'lib/ropencv/ropencv_types.rb', line 89156

def at(size)
validate_index(size)
    __validate_pointer__
    result = Rbind::std_vector_cv_scalar_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::Scalar

Note:

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

Returns:



89181
89182
89183
89184
89185
89186
89187
89188
89189
 
# File 'lib/ropencv/ropencv_types.rb', line 89181

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

Returns:

  • (Size_T) 


89119
89120
89121
89122
 
# File 'lib/ropencv/ropencv_types.rb', line 89119

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

#clear ⇒ Void

Note:

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

Returns:

  • (Void) 


89112
89113
89114
89115
 
# File 'lib/ropencv/ropencv_types.rb', line 89112

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

#data ⇒ Void

Note:

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

Returns:

  • (Void) 


89193
89194
89195
89196
 
# File 'lib/ropencv/ropencv_types.rb', line 89193

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

#delete_if(&block) ⇒ Object 



89250
89251
89252
89253
89254
89255
89256
89257
 
# File 'lib/ropencv/ropencv_types.rb', line 89250

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 



89236
89237
89238
89239
89240
89241
89242
89243
89244
89245
 
# File 'lib/ropencv/ropencv_types.rb', line 89236

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::Scalar::empty()

Returns:

  • (Bool) 


89126
89127
89128
89129
 
# File 'lib/ropencv/ropencv_types.rb', line 89126

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

#front ⇒ Cv::Scalar

Note:

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

Returns:



89169
89170
89171
89172
89173
89174
89175
89176
89177
 
# File 'lib/ropencv/ropencv_types.rb', line 89169

def front()
    __validate_pointer__
    result = Rbind::std_vector_cv_scalar_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::Scalar

Note:

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

Parameters:

  • size (Size_T)

Returns:



89225
89226
89227
89228
89229
89230
89231
89232
89233
89234
 
# File 'lib/ropencv/ropencv_types.rb', line 89225

def [](size)
validate_index(size)
    __validate_pointer__
    result = Rbind::std_vector_cv_scalar_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::Scalar::pop_back()

Returns:

  • (Void) 


89208
89209
89210
89211
 
# File 'lib/ropencv/ropencv_types.rb', line 89208

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

#push_back(other) ⇒ Void

Note:

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

Parameters:

Returns:

  • (Void) 


89201
89202
89203
89204
 
# File 'lib/ropencv/ropencv_types.rb', line 89201

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

#reserve(size) ⇒ Void

Note:

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

Parameters:

  • size (Size_T)

Returns:

  • (Void) 


89134
89135
89136
89137
 
# File 'lib/ropencv/ropencv_types.rb', line 89134

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

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

Note:

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

methods

Parameters:

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

Returns:

  • (Void) 


89098
89099
89100
89101
 
# File 'lib/ropencv/ropencv_types.rb', line 89098

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

#size ⇒ Size_T

Note:

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

Returns:

  • (Size_T) 


89105
89106
89107
89108
 
# File 'lib/ropencv/ropencv_types.rb', line 89105

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

#swap(other) ⇒ Void

Note:

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

Parameters:

Returns:

  • (Void) 


89216
89217
89218
89219
 
# File 'lib/ropencv/ropencv_types.rb', line 89216

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

#to_s ⇒ Object

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



89085
89086
89087
 
# File 'lib/ropencv/ropencv_types.rb', line 89085

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

#validate_index(idx) ⇒ Object 



89231
89232
89233
89234
89235
 
# File 'lib/ropencv/ropencv_types.rb', line 89231

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