Skip to content

# `flContour`

## fontlab.flContour = class flContour(object)

      flContour representation

      Constructors:
        flContour()
        flContour(flObject)
        flContour(flContour)
        flContour(fgContour)
        flContour(id)
        flContour(list(Node)[, bool closed=false])
        flContour(list(QPointF)[, flNode::NodeType=flNode::On[, bool closed=false]])
        flContour(QRectF)
        flContour(QLineF)

#### Methods

__delattr__(...)

      x.__delattr__('name') <==> del x.name

__eq__(...)

      x.__eq__(y) <==> x==y

__ge__(...)

      x.__ge__(y) <==> x>=y

__getattribute__(...)

      x.__getattribute__('name') <==> x.name

__gt__(...)

      x.__gt__(y) <==> x>y

__init__(...)

      x.__init__(...) initializes x; see help(type(x)) for signature

__le__(...)

      x.__le__(y) <==> x<=y

__lt__(...)

      x.__lt__(y) <==> x

__ne__(...)

      x.__ne__(y) <==> x!=y

__repr__(...)

      x.__repr__() <==> repr(x)

__setattr__(...)

      x.__setattr__('name', value) <==> x.name = value

add(...)

      add(flNode | QPointF)

addInterval(...)

      addInterval(Interval)

addMarker(...)

      addMarker( flContourMarker)

addMarkers(...)

      addMarkers( list(flContourMarker) )

append(...)

      append(list(flNode) | flContour)

appendMapped(...)

      appendMapped(list(flNode) | flContour, QTransform)

appendMarkers(...)

      appendMarkers(list(flContourMarker))

applyTransform(...)

      applyTransform()

assign(...)

      assign(flContour | fgContour | list(flNode))

assignOwner(...)

      assignOwner()

at(...)

      flNode at(int index)

autoG2(...)

      autoG2(float tolerance)

beautify(...)

      bool beautify([int precision = 1])

bindDependencies(...)

      bindDependencies()

boundingBox(...)

      QRectF boundingBox([QTransform])

breakContour(...)

      (flContour, flNode, flNode)/Nothing breakContour(flNode) | flContour/Nothing breakContour(int node_ix)

breakContourExpanded(...)

      flContour/Nothing breakContourExpanded(int node_ix | flNode [, float extrapolate_d]

calculate(...)

      QPointF calculate(float t[, QTransform tx])

changed(...)

      changed()

checkFa(...)

      list(FaBasic) checkFa(list(int) tests)

checkInitHistoryState(...)

      checkInitHistoryState(uint history_ix)

checkSmooth(...)

      checkSmooth()

clearAboveHistory(...)

      clearAboveHistory(uint history_ix)

clearFlag(...)

      clearFlag(uint f)

clearFlags(...)

      clearFlags()

clearIntervals(...)

      clearIntervals([uint key])

clearMarkers(...)

      clearMarkers()

clearNodes(...)

      clearNodes()

clone(...)

      Clone the object

cloneMapped(...)

      flContour cloneMapped(QTransform[, float ex_t0, float ex_t1])

cloneMappedByT(...)

      flContour cloneMappedByT(QTransform tx, float t0, float t1)

cloneSelected(...)

      list(flContour)/Nothing cloneSelected([QTransform, [bool ignore_alone=true]])

compare(...)

      (bool result, QPointF offset) compare(flContour, float error)

contains(...)

      bool contains(flContour knife | QPointF)

convertClToT(...)

      float convertClToT(float)

convertExToCl(...)

      float convertExToCl(float)

convertExToT(...)

      float convertExToT(float)

convertTTtoCurve(...)

      convertTTtoCurve()

convertToFgContour(...)

      fgContour convertToFgContour([QTransform tx])

convertTtoCl(...)

      float convertTtoCl(float)

convertTtoEx(...)

      float convertTtoEx(float)

createHistoryState(...)

      createHistoryState(uint history_ix)

currentHistoryState(...)

      currentHistoryIx()

curvature(...)

      float  curvature(float)

derivative(...)

      QPointF derivative(float)

distanceBetween(...)

      float distanceBetween(float t0, float t1[, float step =0.1])

draw(...)

      draw(pen) - Draw the contour’s outline data to the given type-pen

drawPoints(...)

      drawPoints(point-pen) - Draw the contour’s outline data to the given type-point-pen

extrapolateFirst(...)

      extrapolateFirst(float)

extrapolateLast(...)

      extrapolateLast(float)

fastAppend(...)

      fastAppend( list(flNode) )

fastClone(...)

      flContour fastClone(float ex_t0, float ex_t1)

fastCloneByT(...)

      flContour fastCloneByT(float t0, float t1)

find(...)

      flNode find(QPointF, float, flNode::NodeType)

findNearest(...)

      (float out_nearest_t, float dist)/Nothing findNearest(QPointF shape_p[, int orientation=0])

findNearestNode(...)

      (flNode, float new_maxd)/Nothing findNearestNode(QPointF p, flNode::NodeType node_type, float maxd)

findNearestOn(...)

      float out_nearest_t/Nothing findNearestOn(QPointF  p, float base_t)

findNode(...)

      flNode/Nothing findNode(uint id | string name)

flag(...)

      flag(uint f)

getBoundedT(...)

      float getBoundedT(float param_t, float radius)

getChangesRect(...)

      QRectF getChangesRect()

getFirstPoint(...)

      QPointF/Nothing getFirstPoint([int =0])

getIntervals(...)

      list(Interval) getIntervals(uint key)

getLastPoint(...)

      QPointF/Nothing getLastPoint([int =0])

getLength(...)

      float getLength([float t0, float t1,] int =10)

getLengthSquareBRect(...)

      (float square, float length, QRectF brect) getLengthSquareBRect(float t0, float t1[, int step=10])

getNext(...)

      flNode/Nothing getNext(index[, flNode::NodeType=flNode::On])

getNextT(...)

      (bool, float) getNextT(float base_t, float offset)

getNodeAt(...)

      flNode/Nothing getNodeAt(int idx[, flNode::NodeType = flNode::AnyNodeMask])

getPoint(...)

      QPointF/Nothing getPoint(int idx[, flNode::NodeType = flNode::On])

getPrev(...)

      flNode/Nothing getPrev(index[, flNode::NodeType=flNode::On])

getPrevT(...)

      (bool, float) getPrevT(float base_t, float offset)

getProperties(...)

      Get object's properties list

getProperty(...)

      getProperty('key') - get object property by 'key' or number

getPropertyFloat(...)

      getPropertyFloat('key') - get float object property by 'key'

getPropertyInt(...)

      getPropertyInt('key') - get int object property by 'key'

getSegment(...)

      list(flNode) getSegment(int i0, int i1, bool left)

getSelectedBoundingBox(...)

      QRectF getSelectedBoundingBox()

getSelectedNodes(...)

      list(flNode)/Nothing getSelectedNodes()

getSideOf(...)

      float getSideOf(QPointF p)

getSquare(...)

      double getSquare()

getT(...)

      float getT(flNode)

getUpdateRect(...)

      QRectF getUpdateRect(float ex_t)

hasHistoryState(...)

      hasHistoryState(uint history_ix)

hasIntersPoints(...)

      bool hasIntersPoints(flContour)

hasSelected(...)

      bool hasSelected(SelectionMode)

historyStates(...)

      historyStates(bool accepted_state)

improve(...)

      bool improve()

indentParamT(...)

      float indentParamT(float base_t, float indent[, float step =0.1])

independedAll(...)

      independedAll()

initialHistoryState(...)

      initialHistoryIx()

inkBox(...)

      QRectF inkBox([QTransform tx])

insert(...)

      insert(index, flNode | list(flNode) )

insertNodeTo(...)

      flNode insertNodeTo(float t)

insertSafeNodeTo(...)

      flNode insertSafeNodeTo(float t, float dst)

intervals(...)

      list(Interval) intervals()

isAllNodesSelected(...)

      bool isAllNodesSelected()

isCompatible(...)

      bool isCompatible(flContour, bool strong)

isEqual(...)

      isEqual(flObject)

isFirst(...)

      bool isFirst(flNode)

isLast(...)

      bool isLast(flNode)

isSelected(...)

      bool isSelected(float)

mapParamT(...)

      float mapParamT(float, float, float)

markers(...)

      list(flContourMarker) markers()

move(...)

      move(QPointF)

nodes(...)

      list(flNode) nodes()

normalAt(...)

      float normalAt(float t[, QTransform])

normalPoint(...)

      QPointF normalPoint(float t, float length)

normalizeExT(...)

      float normalizeExT(float)

path(...)

      QPainterPath path()

pointInside(...)

      pointInside(QPointF pt) - Bool indicating if the point pt in the black area of the contour

pointf(...)

      QPointF pointf(int index)

release(...)

      release()

remove(...)

      remove([flObject])

removeAt(...)

      removeAt(int index)

removeChild(...)

      removeChild(flObject)

removeLast(...)

      removeLast()

removeMarker(...)

      removeMarker( flContourMarker )

removeNodesBetween(...)

      removeNodesBetween(flNode prev,  flNode next)

removeOne(...)

      removeOne(flNode)

removeProperty(...)

      removeProperty('key')

replace(...)

      replace(flNode old_node, flNode new_node)

restoreHistoryState(...)

      restoreHistoryState(uint history_ix)

reverse(...)

      reverse() - Reverse the direction of the contour

secondDerivative(...)

      QPointF secondDerivative(float)

segment(...)

      CurveEx/Nothing segment(float t)

segments(...)

      list(CurveEx) segments()

selectedPath(...)

      QPainterPath selectedPath()

selectionChanged(...)

      selectionChanged()

setFlag(...)

      setFlag(uint f [, bool value])

setNext(...)

      flNode setNext(int, QPointF)

setPoint(...)

      flNode setPoint(int index, QPointF p)

setPrev(...)

      flNode setPrev(int, QPointF)

setProperty(...)

      setProperty('key', value) - set object property by 'key' or number

setPropertyFloat(...)

      setPropertyFloat('key', value) - set float object property by 'key'

setPropertyInt(...)

      setPropertyInt('key', value) - set int object property by 'key'

setSelectedNodes(...)

      setSelectedNodes(bool)

setStartPoint(...)

      bool setStartPoint(int i)

simplify(...)

      simplify(float precision, bool lossy, bool extremes)

tag(...)

      tag([string])

takeNodes(...)

      list(flNode) takeNodes()

tangent(...)

      float tangent(float t)

toBeziers(...)

      toBeziers(float tolerance)

toSplines(...)

      toSplines(float tolerance, bool short_splines)

unselectAll(...)

      unselectAll()

unselectedPath(...)

      QPainterPath unselectedPath()

update(...)

      update()

updateG2(...)

      updateG2(bool all_nodes)

updateHobby(...)

      updateHobby(bool all_nodes)

updateIndices(...)

      updateIndices()

validateExT(...)

      (new_ex_t, bool) validateExT(float ex_t)

validateIndex(...)

      (new_inx, bool) validateIndex(int inx)

validateSmartR(...)

      (new_r, max_available_r, bool) validateSmartR(int node_ix, float r)

validateT(...)

      (new_t, bool) validateT(float t)

validatedT(...)

      float validatedT(float t)

verifySmooth(...)

      verifySmooth()

#### Static methods

cloneObject(...)

      flObject cloneObject(const flObject&);

createObject(...)

      flObject/Nothing createObject(int);

haveObject(...)

      bool haveObject(uint);

instanceType(...)

      int instanceType();

#### Descriptors

bounds

      The bounds of the contour as tuple (xMin, yMin, xMax, yMax) or None

clockwise

      Bool indicating if the contour’s winding direction is clockwise

closed

      closed attribute

closedT0

      closedT0 attr

closedT1

      closedT1 attr

first

      first node

font

      The contour’s parent font

glyph

      The contour’s parent glyph

hasChanges

      bool

hasCorners

      hasCorners

hasHistoryStates

      bool

hasSmartAngle

      hasSmartAngle

id

      object id

isChanged

      bool

isComplete

      isComplete

isNull

      bool

isPresent

      bool

isReleased

      bool

isTT

      is truetype

isValid

      bool

last

      last node

layer

      The contour’s parent layer

name

      object name

nodesCount

      nodes count

paramT0

      paramT0 attr

paramT1

      paramT1 attr

paramsClosed

      paramsClosed attribute

prevLast

      last but one node

refCnt

      object references count

reversed

      reversed

selection

      selection list (list)

transform

      transform matrix

type

      object type

#### Attributes

FigureType = {'figureEllipse': 1, 'figureRectangle': 2}

__new__ = <built-in method __new__ of type object>

      T.__new__(S, ...) -> a new object with type S, a subtype of T

flObjectFlags = {'ofAnchored': 64, 'ofChanged': 2, 'ofHistory': 128, 'ofIgnore': 8, 'ofIgnoreChanges': 4, 'ofPassive': 16, 'ofReleased': 1, 'ofSlowUpdate': 32}

## `add`

fontlab.flContour.add = add(...)

      add(flNode | QPointF)

## `addInterval`

fontlab.flContour.addInterval = addInterval(...)

      addInterval(Interval)

## `addMarker`

fontlab.flContour.addMarker = addMarker(...)

      addMarker( flContourMarker)

## `addMarkers`

fontlab.flContour.addMarkers = addMarkers(...)

      addMarkers( list(flContourMarker) )

## `append`

fontlab.flContour.append = append(...)

      append(list(flNode) | flContour)

## `appendMapped`

fontlab.flContour.appendMapped = appendMapped(...)

      appendMapped(list(flNode) | flContour, QTransform)

## `appendMarkers`

fontlab.flContour.appendMarkers = appendMarkers(...)

      appendMarkers(list(flContourMarker))

## `applyTransform`

fontlab.flContour.applyTransform = applyTransform(...)

      applyTransform()

## `assign`

fontlab.flContour.assign = assign(...)

      assign(flContour | fgContour | list(flNode))

## `assignOwner`

fontlab.flContour.assignOwner = assignOwner(...)

      assignOwner()

## `at`

fontlab.flContour.at = at(...)

      flNode at(int index)

## `autoG2`

fontlab.flContour.autoG2 = autoG2(...)

      autoG2(float tolerance)

## `beautify`

fontlab.flContour.beautify = beautify(...)

      bool beautify([int precision = 1])

## `bindDependencies`

fontlab.flContour.bindDependencies = bindDependencies(...)

      bindDependencies()

## `boundingBox`

fontlab.flContour.boundingBox = boundingBox(...)

      QRectF boundingBox([QTransform])

## `bounds`

fontlab.flContour.bounds

      The bounds of the contour as tuple (xMin, yMin, xMax, yMax) or None

## `breakContour`

fontlab.flContour.breakContour = breakContour(...)

      (flContour, flNode, flNode)/Nothing breakContour(flNode) | flContour/Nothing breakContour(int node_ix)

## `breakContourExpanded`

fontlab.flContour.breakContourExpanded = breakContourExpanded(...)

      flContour/Nothing breakContourExpanded(int node_ix | flNode [, float extrapolate_d]

## `calculate`

fontlab.flContour.calculate = calculate(...)

      QPointF calculate(float t[, QTransform tx])

## `changed`

fontlab.flContour.changed = changed(...)

      changed()

## `checkFa`

fontlab.flContour.checkFa = checkFa(...)

      list(FaBasic) checkFa(list(int) tests)

## `checkInitHistoryState`

fontlab.flContour.checkInitHistoryState = checkInitHistoryState(...)

      checkInitHistoryState(uint history_ix)

## `checkSmooth`

fontlab.flContour.checkSmooth = checkSmooth(...)

      checkSmooth()

## `clearAboveHistory`

fontlab.flContour.clearAboveHistory = clearAboveHistory(...)

      clearAboveHistory(uint history_ix)

## `clearFlag`

fontlab.flContour.clearFlag = clearFlag(...)

      clearFlag(uint f)

## `clearFlags`

fontlab.flContour.clearFlags = clearFlags(...)

      clearFlags()

## `clearIntervals`

fontlab.flContour.clearIntervals = clearIntervals(...)

      clearIntervals([uint key])

## `clearMarkers`

fontlab.flContour.clearMarkers = clearMarkers(...)

      clearMarkers()

## `clearNodes`

fontlab.flContour.clearNodes = clearNodes(...)

      clearNodes()

## `clockwise`

fontlab.flContour.clockwise

      Bool indicating if the contour’s winding direction is clockwise

## `clone`

fontlab.flContour.clone = clone(...)

      Clone the object

## `cloneMapped`

fontlab.flContour.cloneMapped = cloneMapped(...)

      flContour cloneMapped(QTransform[, float ex_t0, float ex_t1])

## `cloneMappedByT`

fontlab.flContour.cloneMappedByT = cloneMappedByT(...)

      flContour cloneMappedByT(QTransform tx, float t0, float t1)

## `cloneObject`

fontlab.flContour.cloneObject = cloneObject(...)

      flObject cloneObject(const flObject&);

## `cloneSelected`

fontlab.flContour.cloneSelected = cloneSelected(...)

      list(flContour)/Nothing cloneSelected([QTransform, [bool ignore_alone=true]])

## `closed`

fontlab.flContour.closed

      closed attribute

## `closedT0`

fontlab.flContour.closedT0

      closedT0 attr

## `closedT1`

fontlab.flContour.closedT1

      closedT1 attr

## `compare`

fontlab.flContour.compare = compare(...)

      (bool result, QPointF offset) compare(flContour, float error)

## `contains`

fontlab.flContour.contains = contains(...)

      bool contains(flContour knife | QPointF)

## `convertClToT`

fontlab.flContour.convertClToT = convertClToT(...)

      float convertClToT(float)

## `convertExToCl`

fontlab.flContour.convertExToCl = convertExToCl(...)

      float convertExToCl(float)

## `convertExToT`

fontlab.flContour.convertExToT = convertExToT(...)

      float convertExToT(float)

## `convertToFgContour`

fontlab.flContour.convertToFgContour = convertToFgContour(...)

      fgContour convertToFgContour([QTransform tx])

## `convertTtoCl`

fontlab.flContour.convertTtoCl = convertTtoCl(...)

      float convertTtoCl(float)

## `convertTtoEx`

fontlab.flContour.convertTtoEx = convertTtoEx(...)

      float convertTtoEx(float)

## `convertTTtoCurve`

fontlab.flContour.convertTTtoCurve = convertTTtoCurve(...)

      convertTTtoCurve()

## `createHistoryState`

fontlab.flContour.createHistoryState = createHistoryState(...)

      createHistoryState(uint history_ix)

## `createObject`

fontlab.flContour.createObject = createObject(...)

      flObject/Nothing createObject(int);

## `currentHistoryState`

fontlab.flContour.currentHistoryState = currentHistoryState(...)

      currentHistoryIx()

## `curvature`

fontlab.flContour.curvature = curvature(...)

      float  curvature(float)

## `derivative`

fontlab.flContour.derivative = derivative(...)

      QPointF derivative(float)

## `distanceBetween`

fontlab.flContour.distanceBetween = distanceBetween(...)

      float distanceBetween(float t0, float t1[, float step =0.1])

## `draw`

fontlab.flContour.draw = draw(...)

      draw(pen) - Draw the contour’s outline data to the given type-pen

## `drawPoints`

fontlab.flContour.drawPoints = drawPoints(...)

      drawPoints(point-pen) - Draw the contour’s outline data to the given type-point-pen

## `extrapolateFirst`

fontlab.flContour.extrapolateFirst = extrapolateFirst(...)

      extrapolateFirst(float)

## `extrapolateLast`

fontlab.flContour.extrapolateLast = extrapolateLast(...)

      extrapolateLast(float)

## `fastAppend`

fontlab.flContour.fastAppend = fastAppend(...)

      fastAppend( list(flNode) )

## `fastClone`

fontlab.flContour.fastClone = fastClone(...)

      flContour fastClone(float ex_t0, float ex_t1)

## `fastCloneByT`

fontlab.flContour.fastCloneByT = fastCloneByT(...)

      flContour fastCloneByT(float t0, float t1)

## `FigureType`

fontlab.flContour.FigureType = {'figureEllipse': 1, 'figureRectangle': 2}

## `find`

fontlab.flContour.find = find(...)

      flNode find(QPointF, float, flNode::NodeType)

## `findNearest`

fontlab.flContour.findNearest = findNearest(...)

      (float out_nearest_t, float dist)/Nothing findNearest(QPointF shape_p[, int orientation=0])

## `findNearestNode`

fontlab.flContour.findNearestNode = findNearestNode(...)

      (flNode, float new_maxd)/Nothing findNearestNode(QPointF p, flNode::NodeType node_type, float maxd)

## `findNearestOn`

fontlab.flContour.findNearestOn = findNearestOn(...)

      float out_nearest_t/Nothing findNearestOn(QPointF  p, float base_t)

## `findNode`

fontlab.flContour.findNode = findNode(...)

      flNode/Nothing findNode(uint id | string name)

## `first`

fontlab.flContour.first

      first node

## `flag`

fontlab.flContour.flag = flag(...)

      flag(uint f)

## `flObjectFlags`

fontlab.flContour.flObjectFlags = {'ofAnchored': 64, 'ofChanged': 2, 'ofHistory': 128, 'ofIgnore': 8, 'ofIgnoreChanges': 4, 'ofPassive': 16, 'ofReleased': 1, 'ofSlowUpdate': 32}

## `font`

fontlab.flContour.font

      The contour’s parent font

## `getBoundedT`

fontlab.flContour.getBoundedT = getBoundedT(...)

      float getBoundedT(float param_t, float radius)

## `getChangesRect`

fontlab.flContour.getChangesRect = getChangesRect(...)

      QRectF getChangesRect()

## `getFirstPoint`

fontlab.flContour.getFirstPoint = getFirstPoint(...)

      QPointF/Nothing getFirstPoint([int =0])

## `getIntervals`

fontlab.flContour.getIntervals = getIntervals(...)

      list(Interval) getIntervals(uint key)

## `getLastPoint`

fontlab.flContour.getLastPoint = getLastPoint(...)

      QPointF/Nothing getLastPoint([int =0])

## `getLength`

fontlab.flContour.getLength = getLength(...)

      float getLength([float t0, float t1,] int =10)

## `getLengthSquareBRect`

fontlab.flContour.getLengthSquareBRect = getLengthSquareBRect(...)

      (float square, float length, QRectF brect) getLengthSquareBRect(float t0, float t1[, int step=10])

## `getNext`

fontlab.flContour.getNext = getNext(...)

      flNode/Nothing getNext(index[, flNode::NodeType=flNode::On])

## `getNextT`

fontlab.flContour.getNextT = getNextT(...)

      (bool, float) getNextT(float base_t, float offset)

## `getNodeAt`

fontlab.flContour.getNodeAt = getNodeAt(...)

      flNode/Nothing getNodeAt(int idx[, flNode::NodeType = flNode::AnyNodeMask])

## `getPoint`

fontlab.flContour.getPoint = getPoint(...)

      QPointF/Nothing getPoint(int idx[, flNode::NodeType = flNode::On])

## `getPrev`

fontlab.flContour.getPrev = getPrev(...)

      flNode/Nothing getPrev(index[, flNode::NodeType=flNode::On])

## `getPrevT`

fontlab.flContour.getPrevT = getPrevT(...)

      (bool, float) getPrevT(float base_t, float offset)

## `getProperties`

fontlab.flContour.getProperties = getProperties(...)

      Get object's properties list

## `getProperty`

fontlab.flContour.getProperty = getProperty(...)

      getProperty('key') - get object property by 'key' or number

## `getPropertyFloat`

fontlab.flContour.getPropertyFloat = getPropertyFloat(...)

      getPropertyFloat('key') - get float object property by 'key'

## `getPropertyInt`

fontlab.flContour.getPropertyInt = getPropertyInt(...)

      getPropertyInt('key') - get int object property by 'key'

## `getSegment`

fontlab.flContour.getSegment = getSegment(...)

      list(flNode) getSegment(int i0, int i1, bool left)

## `getSelectedBoundingBox`

fontlab.flContour.getSelectedBoundingBox = getSelectedBoundingBox(...)

      QRectF getSelectedBoundingBox()

## `getSelectedNodes`

fontlab.flContour.getSelectedNodes = getSelectedNodes(...)

      list(flNode)/Nothing getSelectedNodes()

## `getSideOf`

fontlab.flContour.getSideOf = getSideOf(...)

      float getSideOf(QPointF p)

## `getSquare`

fontlab.flContour.getSquare = getSquare(...)

      double getSquare()

## `getT`

fontlab.flContour.getT = getT(...)

      float getT(flNode)

## `getUpdateRect`

fontlab.flContour.getUpdateRect = getUpdateRect(...)

      QRectF getUpdateRect(float ex_t)

## `glyph`

fontlab.flContour.glyph

      The contour’s parent glyph

## `hasChanges`

fontlab.flContour.hasChanges

      bool

## `hasCorners`

fontlab.flContour.hasCorners

      hasCorners

## `hasHistoryState`

fontlab.flContour.hasHistoryState = hasHistoryState(...)

      hasHistoryState(uint history_ix)

## `hasHistoryStates`

fontlab.flContour.hasHistoryStates

      bool

## `hasIntersPoints`

fontlab.flContour.hasIntersPoints = hasIntersPoints(...)

      bool hasIntersPoints(flContour)

## `hasSelected`

fontlab.flContour.hasSelected = hasSelected(...)

      bool hasSelected(SelectionMode)

## `hasSmartAngle`

fontlab.flContour.hasSmartAngle

      hasSmartAngle

## `haveObject`

fontlab.flContour.haveObject = haveObject(...)

      bool haveObject(uint);

## `historyStates`

fontlab.flContour.historyStates = historyStates(...)

      historyStates(bool accepted_state)

## `id`

fontlab.flContour.id

      object id

## `improve`

fontlab.flContour.improve = improve(...)

      bool improve()

## `indentParamT`

fontlab.flContour.indentParamT = indentParamT(...)

      float indentParamT(float base_t, float indent[, float step =0.1])

## `independedAll`

fontlab.flContour.independedAll = independedAll(...)

      independedAll()

## `initialHistoryState`

fontlab.flContour.initialHistoryState = initialHistoryState(...)

      initialHistoryIx()

## `inkBox`

fontlab.flContour.inkBox = inkBox(...)

      QRectF inkBox([QTransform tx])

## `insert`

fontlab.flContour.insert = insert(...)

      insert(index, flNode | list(flNode) )

## `insertNodeTo`

fontlab.flContour.insertNodeTo = insertNodeTo(...)

      flNode insertNodeTo(float t)

## `insertSafeNodeTo`

fontlab.flContour.insertSafeNodeTo = insertSafeNodeTo(...)

      flNode insertSafeNodeTo(float t, float dst)

## `instanceType`

fontlab.flContour.instanceType = instanceType(...)

      int instanceType();

## `intervals`

fontlab.flContour.intervals = intervals(...)

      list(Interval) intervals()

## `isAllNodesSelected`

fontlab.flContour.isAllNodesSelected = isAllNodesSelected(...)

      bool isAllNodesSelected()

## `isChanged`

fontlab.flContour.isChanged

      bool

## `isCompatible`

fontlab.flContour.isCompatible = isCompatible(...)

      bool isCompatible(flContour, bool strong)

## `isComplete`

fontlab.flContour.isComplete

      isComplete

## `isEqual`

fontlab.flContour.isEqual = isEqual(...)

      isEqual(flObject)

## `isFirst`

fontlab.flContour.isFirst = isFirst(...)

      bool isFirst(flNode)

## `isLast`

fontlab.flContour.isLast = isLast(...)

      bool isLast(flNode)

## `isNull`

fontlab.flContour.isNull

      bool

## `isPresent`

fontlab.flContour.isPresent

      bool

## `isReleased`

fontlab.flContour.isReleased

      bool

## `isSelected`

fontlab.flContour.isSelected = isSelected(...)

      bool isSelected(float)

## `isTT`

fontlab.flContour.isTT

      is truetype

## `isValid`

fontlab.flContour.isValid

      bool

## `last`

fontlab.flContour.last

      last node

## `layer`

fontlab.flContour.layer

      The contour’s parent layer

## `mapParamT`

fontlab.flContour.mapParamT = mapParamT(...)

      float mapParamT(float, float, float)

## `markers`

fontlab.flContour.markers = markers(...)

      list(flContourMarker) markers()

## `move`

fontlab.flContour.move = move(...)

      move(QPointF)

## `name`

fontlab.flContour.name

      object name

## `nodes`

fontlab.flContour.nodes = nodes(...)

      list(flNode) nodes()

## `nodesCount`

fontlab.flContour.nodesCount

      nodes count

## `normalAt`

fontlab.flContour.normalAt = normalAt(...)

      float normalAt(float t[, QTransform])

## `normalizeExT`

fontlab.flContour.normalizeExT = normalizeExT(...)

      float normalizeExT(float)

## `normalPoint`

fontlab.flContour.normalPoint = normalPoint(...)

      QPointF normalPoint(float t, float length)

## `paramsClosed`

fontlab.flContour.paramsClosed

      paramsClosed attribute

## `paramT0`

fontlab.flContour.paramT0

      paramT0 attr

## `paramT1`

fontlab.flContour.paramT1

      paramT1 attr

## `path`

fontlab.flContour.path = path(...)

      QPainterPath path()

## `pointf`

fontlab.flContour.pointf = pointf(...)

      QPointF pointf(int index)

## `pointInside`

fontlab.flContour.pointInside = pointInside(...)

      pointInside(QPointF pt) - Bool indicating if the point pt in the black area of the contour

## `prevLast`

fontlab.flContour.prevLast

      last but one node

## `refCnt`

fontlab.flContour.refCnt

      object references count

## `release`

fontlab.flContour.release = release(...)

      release()

## `remove`

fontlab.flContour.remove = remove(...)

      remove([flObject])

## `removeAt`

fontlab.flContour.removeAt = removeAt(...)

      removeAt(int index)

## `removeChild`

fontlab.flContour.removeChild = removeChild(...)

      removeChild(flObject)

## `removeLast`

fontlab.flContour.removeLast = removeLast(...)

      removeLast()

## `removeMarker`

fontlab.flContour.removeMarker = removeMarker(...)

      removeMarker( flContourMarker )

## `removeNodesBetween`

fontlab.flContour.removeNodesBetween = removeNodesBetween(...)

      removeNodesBetween(flNode prev,  flNode next)

## `removeOne`

fontlab.flContour.removeOne = removeOne(...)

      removeOne(flNode)

## `removeProperty`

fontlab.flContour.removeProperty = removeProperty(...)

      removeProperty('key')

## `replace`

fontlab.flContour.replace = replace(...)

      replace(flNode old_node, flNode new_node)

## `restoreHistoryState`

fontlab.flContour.restoreHistoryState = restoreHistoryState(...)

      restoreHistoryState(uint history_ix)

## `reverse`

fontlab.flContour.reverse = reverse(...)

      reverse() - Reverse the direction of the contour

## `reversed`

fontlab.flContour.reversed

      reversed

## `secondDerivative`

fontlab.flContour.secondDerivative = secondDerivative(...)

      QPointF secondDerivative(float)

## `segment`

fontlab.flContour.segment = segment(...)

      CurveEx/Nothing segment(float t)

## `segments`

fontlab.flContour.segments = segments(...)

      list(CurveEx) segments()

## `selectedPath`

fontlab.flContour.selectedPath = selectedPath(...)

      QPainterPath selectedPath()

## `selection`

fontlab.flContour.selection

      selection list (list)

## `selectionChanged`

fontlab.flContour.selectionChanged = selectionChanged(...)

      selectionChanged()

## `setFlag`

fontlab.flContour.setFlag = setFlag(...)

      setFlag(uint f [, bool value])

## `setNext`

fontlab.flContour.setNext = setNext(...)

      flNode setNext(int, QPointF)

## `setPoint`

fontlab.flContour.setPoint = setPoint(...)

      flNode setPoint(int index, QPointF p)

## `setPrev`

fontlab.flContour.setPrev = setPrev(...)

      flNode setPrev(int, QPointF)

## `setProperty`

fontlab.flContour.setProperty = setProperty(...)

      setProperty('key', value) - set object property by 'key' or number

## `setPropertyFloat`

fontlab.flContour.setPropertyFloat = setPropertyFloat(...)

      setPropertyFloat('key', value) - set float object property by 'key'

## `setPropertyInt`

fontlab.flContour.setPropertyInt = setPropertyInt(...)

      setPropertyInt('key', value) - set int object property by 'key'

## `setSelectedNodes`

fontlab.flContour.setSelectedNodes = setSelectedNodes(...)

      setSelectedNodes(bool)

## `setStartPoint`

fontlab.flContour.setStartPoint = setStartPoint(...)

      bool setStartPoint(int i)

## `simplify`

fontlab.flContour.simplify = simplify(...)

      simplify(float precision, bool lossy, bool extremes)

## `tag`

fontlab.flContour.tag = tag(...)

      tag([string])

## `takeNodes`

fontlab.flContour.takeNodes = takeNodes(...)

      list(flNode) takeNodes()

## `tangent`

fontlab.flContour.tangent = tangent(...)

      float tangent(float t)

## `toBeziers`

fontlab.flContour.toBeziers = toBeziers(...)

      toBeziers(float tolerance)

## `toSplines`

fontlab.flContour.toSplines = toSplines(...)

      toSplines(float tolerance, bool short_splines)

## `transform`

fontlab.flContour.transform

      transform matrix

## `type`

fontlab.flContour.type

      object type

## `unselectAll`

fontlab.flContour.unselectAll = unselectAll(...)

      unselectAll()

## `unselectedPath`

fontlab.flContour.unselectedPath = unselectedPath(...)

      QPainterPath unselectedPath()

## `update`

fontlab.flContour.update = update(...)

      update()

## `updateG2`

fontlab.flContour.updateG2 = updateG2(...)

      updateG2(bool all_nodes)

## `updateHobby`

fontlab.flContour.updateHobby = updateHobby(...)

      updateHobby(bool all_nodes)

## `updateIndices`

fontlab.flContour.updateIndices = updateIndices(...)

      updateIndices()

## `validatedT`

fontlab.flContour.validatedT = validatedT(...)

      float validatedT(float t)

## `validateExT`

fontlab.flContour.validateExT = validateExT(...)

      (new_ex_t, bool) validateExT(float ex_t)

## `validateIndex`

fontlab.flContour.validateIndex = validateIndex(...)

      (new_inx, bool) validateIndex(int inx)

## `validateSmartR`

fontlab.flContour.validateSmartR = validateSmartR(...)

      (new_r, max_available_r, bool) validateSmartR(int node_ix, float r)

## `validateT`

fontlab.flContour.validateT = validateT(...)

      (new_t, bool) validateT(float t)

## `verifySmooth`

fontlab.flContour.verifySmooth = verifySmooth(...)

      verifySmooth()