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.