Skip to content

typerig.core.objects.delta

typerig.core.objects.delta (version 0.10.4)

# MODULE: TypeRig / Core / Delta (Objects)
# -----------------------------------------------------------
# (C) Vassil Kateliev, 2018-2020        (http://www.kateliev.com)
# (C) Karandash Type Foundry            (http://www.karandash.eu)
#------------------------------------------------------------
# www.typerig.com

Modules

  • math
  • typerig.core.func.transform

Classes

class DeltaArray(_abcoll.Sequence)

# - Objects ------------------------------------
# -- Interpolation ------------------------------
Method resolution order:
DeltaArray
_abcoll.Sequence
_abcoll.Sized
_abcoll.Iterable
_abcoll.Container
__builtin__.object

Methods

__call__(self, global_time, extrapolate=False)
Linear interpolation (LERP) with optional extrapolation.
Interval (-inf) <-- (0 .. len(array)-1) --> (+inf) (supports negative indexing).
__getitem__(self, i)
# - Internals
__hash__(self)





__init__(self, data)








__len__(self)








__repr__(self)








mixer(self, global_time)



Will return the proper coordinate values for the selected global time.





timer(self, global_time, extrapolate=False)








  
Attributes 
__abstractmethods__ = frozenset([])


  
Methods from _abcoll.Sequence
__contains__(self, value)








__iter__(self)








__reversed__(self)








count(self, value)



S.count(value) -> integer -- return number of occurrences of value





index(self, value)



S.index(value) -> integer -- return first index of value.
Raises ValueError if the value is not present.





  
Class methods from _abcoll.Sized
__subclasshook__(cls, C) from abc.ABCMeta








  
Descriptors from _abcoll.Sized
__dict__





dictionary for instance variables (if defined)







__weakref__





list of weak references to the object (if defined)







  
Attributes from _abcoll.Sized
__metaclass__ = <class 'abc.ABCMeta'>



Metaclass for defining Abstract Base Classes (ABCs).

Use this metaclass to create an ABC.  An ABC can be subclassed
directly, and then acts as a mix-in class.  You can also register
unrelated concrete classes (even built-in classes) and unrelated
ABCs as 'virtual subclasses' -- these and their descendants will
be considered subclasses of the registering ABC by the built-in
issubclass() function, but the registering ABC won't show up in
their MRO (Method Resolution Order) nor will method
implementations defined by the registering ABC be callable (not
even via super()).






class DeltaScale(_abcoll.Sequence)








  
Method resolution order:
DeltaScale
_abcoll.Sequence
_abcoll.Sized
_abcoll.Iterable
_abcoll.Container
__builtin__.object
Methods 
__getitem__(self, index)








__init__(self, *argv)








__len__(self)








__repr__(self)



# - Internals ----------------------------------





dump(self)



# - IO ---------------------------------------





load(self, other)








scale_by_stem(self, stem, scale, comp, shift, italic_angle, extrapolate=False)








scale_by_time(self, time, scale, comp, shift, italic_angle, extrapolate=False)



# - Process ----------------------------------





  
Descriptors 
dim




  
Attributes 
__abstractmethods__ = frozenset([])


__setitem__ = None


  
Methods from _abcoll.Sequence
__contains__(self, value)








__iter__(self)








__reversed__(self)








count(self, value)



S.count(value) -> integer -- return number of occurrences of value





index(self, value)



S.index(value) -> integer -- return first index of value.
Raises ValueError if the value is not present.





  
Class methods from _abcoll.Sized
__subclasshook__(cls, C) from abc.ABCMeta








  
Descriptors from _abcoll.Sized
__dict__





dictionary for instance variables (if defined)







__weakref__





list of weak references to the object (if defined)







  
Attributes from _abcoll.Sized
__metaclass__ = <class 'abc.ABCMeta'>



Metaclass for defining Abstract Base Classes (ABCs).

Use this metaclass to create an ABC.  An ABC can be subclassed
directly, and then acts as a mix-in class.  You can also register
unrelated concrete classes (even built-in classes) and unrelated
ABCs as 'virtual subclasses' -- these and their descendants will
be considered subclasses of the registering ABC by the built-in
issubclass() function, but the registering ABC won't show up in
their MRO (Method Resolution Order) nor will method
implementations defined by the registering ABC be callable (not
even via super()).










DeltaArray


typerig.core.objects.delta.DeltaArray = class DeltaArray(_abcoll.Sequence)






# - Objects ------------------------------------
# -- Interpolation ------------------------------




  
Method resolution order:
DeltaArray
_abcoll.Sequence
_abcoll.Sized
_abcoll.Iterable
_abcoll.Container
__builtin__.object
Methods 
__call__(self, global_time, extrapolate=False)



Linear interpolation (LERP) with optional extrapolation.
Interval (-inf) <-- (0 .. len(array)-1) --> (+inf) (supports negative indexing).





__getitem__(self, i)



# - Internals





__hash__(self)








__init__(self, data)








__len__(self)








__repr__(self)








mixer(self, global_time)



Will return the proper coordinate values for the selected global time.





timer(self, global_time, extrapolate=False)








  
Attributes 
__abstractmethods__ = frozenset([])


  
Methods from _abcoll.Sequence
__contains__(self, value)








__iter__(self)








__reversed__(self)








count(self, value)



S.count(value) -> integer -- return number of occurrences of value





index(self, value)



S.index(value) -> integer -- return first index of value.
Raises ValueError if the value is not present.





  
Class methods from _abcoll.Sized
__subclasshook__(cls, C) from abc.ABCMeta








  
Descriptors from _abcoll.Sized
__dict__





dictionary for instance variables (if defined)







__weakref__





list of weak references to the object (if defined)







  
Attributes from _abcoll.Sized
__metaclass__ = <class 'abc.ABCMeta'>



Metaclass for defining Abstract Base Classes (ABCs).

Use this metaclass to create an ABC.  An ABC can be subclassed
directly, and then acts as a mix-in class.  You can also register
unrelated concrete classes (even built-in classes) and unrelated
ABCs as 'virtual subclasses' -- these and their descendants will
be considered subclasses of the registering ABC by the built-in
issubclass() function, but the registering ABC won't show up in
their MRO (Method Resolution Order) nor will method
implementations defined by the registering ABC be callable (not
even via super()).









mixer


typerig.core.objects.delta.DeltaArray.mixer = mixer(self, global_time) unbound typerig.core.objects.delta.DeltaArray method



Will return the proper coordinate values for the selected global time.