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

- _abcoll.Sequence(_abcoll.Sized, _abcoll.Iterable, _abcoll.Container)
- - DeltaArray
  - DeltaScale

## 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.