arrlibct module

arrlibct - A ctypes based python wrapper module for arrlib.dll

Extensive support for basic 2D and 3D geometric objects and basic operations on these.

class arrlibct.c_TypeDescriptor

Bases: _ctypes.Structure

endianSwap

Structure/Union member

formatStr

Structure/Union member

size

Structure/Union member

strFunc

Structure/Union member

typeName

Structure/Union member

arrlibct.getTypeDescriptor(name)

name: string returns: TypeDescriptor *

class arrlibct.c_ArrHead

Bases: _ctypes.Structure

allocPtr

Structure/Union member

chain

Structure/Union member

chainLevel

Structure/Union member

elemType

Structure/Union member

flags

Structure/Union member

m

Structure/Union member

n

Structure/Union member

nextChunk

Structure/Union member

parent

Structure/Union member

signature

Structure/Union member

tag

Structure/Union member

class arrlibct.c_ChunkyVecState

Bases: _ctypes.Structure

chunkSize

Structure/Union member

currIndex

Structure/Union member

elemType

Structure/Union member

firstChunk

Structure/Union member

increasePercent

Structure/Union member

lastChunk

Structure/Union member

class arrlibct.c_Complex32

Bases: _ctypes.Structure

i

Structure/Union member

r

Structure/Union member

class arrlibct.c_Complex64

Bases: _ctypes.Structure

i

Structure/Union member

r

Structure/Union member

class arrlibct.c_XYi(*a)

Bases: _ctypes.Structure

x

Structure/Union member

y

Structure/Union member

class arrlibct.c_XYx(*a)

Bases: _ctypes.Structure

x

Structure/Union member

y

Structure/Union member

class arrlibct.c_XYu(*a)

Bases: _ctypes.Structure

x

Structure/Union member

y

Structure/Union member

class arrlibct.c_XYd(*a)

Bases: _ctypes.Structure

x

Structure/Union member

y

Structure/Union member

class arrlibct.c_XYf(*a)

Bases: _ctypes.Structure

x

Structure/Union member

y

Structure/Union member

class arrlibct.c_XYZi(*a)

Bases: _ctypes.Structure

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZx(*a)

Bases: _ctypes.Structure

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZu(*a)

Bases: _ctypes.Structure

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZd(*a)

Bases: _ctypes.Structure

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZf(*a)

Bases: _ctypes.Structure

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZWi(*a)

Bases: _ctypes.Structure

w

Structure/Union member

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZWx(*a)

Bases: _ctypes.Structure

w

Structure/Union member

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZWu(*a)

Bases: _ctypes.Structure

w

Structure/Union member

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZWd(*a)

Bases: _ctypes.Structure

w

Structure/Union member

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZWf(*a)

Bases: _ctypes.Structure

w

Structure/Union member

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZWVi(*a)

Bases: _ctypes.Structure

v

Structure/Union member

w

Structure/Union member

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZWVx(*a)

Bases: _ctypes.Structure

v

Structure/Union member

w

Structure/Union member

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZWVu(*a)

Bases: _ctypes.Structure

v

Structure/Union member

w

Structure/Union member

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZWVd(*a)

Bases: _ctypes.Structure

v

Structure/Union member

w

Structure/Union member

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_XYZWVf(*a)

Bases: _ctypes.Structure

v

Structure/Union member

w

Structure/Union member

x

Structure/Union member

y

Structure/Union member

z

Structure/Union member

class arrlibct.c_M22f(*a)

Bases: _ctypes.Structure

m11

Structure/Union member

m12

Structure/Union member

m21

Structure/Union member

m22

Structure/Union member

class arrlibct.c_M22d(*a)

Bases: _ctypes.Structure

m11

Structure/Union member

m12

Structure/Union member

m21

Structure/Union member

m22

Structure/Union member

class arrlibct.c_M33f(*a)

Bases: _ctypes.Structure

m11

Structure/Union member

m12

Structure/Union member

m13

Structure/Union member

m21

Structure/Union member

m22

Structure/Union member

m23

Structure/Union member

m31

Structure/Union member

m32

Structure/Union member

m33

Structure/Union member

class arrlibct.c_M33d(*a)

Bases: _ctypes.Structure

m11

Structure/Union member

m12

Structure/Union member

m13

Structure/Union member

m21

Structure/Union member

m22

Structure/Union member

m23

Structure/Union member

m31

Structure/Union member

m32

Structure/Union member

m33

Structure/Union member

class arrlibct.c_M43f(*a)

Bases: _ctypes.Structure

m11

Structure/Union member

m12

Structure/Union member

m13

Structure/Union member

m21

Structure/Union member

m22

Structure/Union member

m23

Structure/Union member

m31

Structure/Union member

m32

Structure/Union member

m33

Structure/Union member

m41

Structure/Union member

m42

Structure/Union member

m43

Structure/Union member

class arrlibct.c_M43d(*a)

Bases: _ctypes.Structure

m11

Structure/Union member

m12

Structure/Union member

m13

Structure/Union member

m21

Structure/Union member

m22

Structure/Union member

m23

Structure/Union member

m31

Structure/Union member

m32

Structure/Union member

m33

Structure/Union member

m41

Structure/Union member

m42

Structure/Union member

m43

Structure/Union member

class arrlibct.c_M44f(*a)

Bases: _ctypes.Structure

m11

Structure/Union member

m12

Structure/Union member

m13

Structure/Union member

m14

Structure/Union member

m21

Structure/Union member

m22

Structure/Union member

m23

Structure/Union member

m24

Structure/Union member

m31

Structure/Union member

m32

Structure/Union member

m33

Structure/Union member

m34

Structure/Union member

m41

Structure/Union member

m42

Structure/Union member

m43

Structure/Union member

m44

Structure/Union member

class arrlibct.c_M44d(*a)

Bases: _ctypes.Structure

m11

Structure/Union member

m12

Structure/Union member

m13

Structure/Union member

m14

Structure/Union member

m21

Structure/Union member

m22

Structure/Union member

m23

Structure/Union member

m24

Structure/Union member

m31

Structure/Union member

m32

Structure/Union member

m33

Structure/Union member

m34

Structure/Union member

m41

Structure/Union member

m42

Structure/Union member

m43

Structure/Union member

m44

Structure/Union member

class arrlibct.c_Box1i(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Box1x(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Box1f(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Box1d(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Box2i(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Box2x(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Box2f(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Box2d(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Box3i(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Box3x(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Box3f(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Box3d(*a)

Bases: _ctypes.Structure

max

Structure/Union member

min

Structure/Union member

class arrlibct.c_Lin1i(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Lin1x(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Lin1f(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Lin1d(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Lin2i(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Lin2x(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Lin2f(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Lin2d(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Lin3i(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Lin3x(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Lin3f(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Lin3d(*a)

Bases: _ctypes.Structure

p

Structure/Union member

v

Structure/Union member

class arrlibct.c_Pose2d(*a)

Bases: _ctypes.Structure

U

Structure/Union member

t

Structure/Union member

class arrlibct.c_Pose2f(*a)

Bases: _ctypes.Structure

U

Structure/Union member

t

Structure/Union member

class arrlibct.c_Pose3d(*a)

Bases: _ctypes.Structure

U

Structure/Union member

t

Structure/Union member

class arrlibct.c_Pose3f(*a)

Bases: _ctypes.Structure

U

Structure/Union member

t

Structure/Union member

class arrlibct.c_Cir2d

Bases: _ctypes.Structure

c

Structure/Union member

r

Structure/Union member

class arrlibct.c_Cir2f

Bases: _ctypes.Structure

c

Structure/Union member

r

Structure/Union member

class arrlibct.c_Cir3d

Bases: _ctypes.Structure

c

Structure/Union member

r

Structure/Union member

class arrlibct.c_Cir3f

Bases: _ctypes.Structure

c

Structure/Union member

r

Structure/Union member

class arrlibct.c_FastPolar

Bases: _ctypes.Structure

angle

Structure/Union member

radius

Structure/Union member

class arrlibct.c_RGB

Bases: _ctypes.Structure

b

Structure/Union member

g

Structure/Union member

pad

Structure/Union member

r

Structure/Union member

class arrlibct.c_HSI

Bases: _ctypes.Structure

h

Structure/Union member

i

Structure/Union member

s

Structure/Union member

class arrlibct.c_RGBf

Bases: _ctypes.Structure

b

Structure/Union member

g

Structure/Union member

r

Structure/Union member

class arrlibct.c_HSIf

Bases: _ctypes.Structure

h

Structure/Union member

i

Structure/Union member

s

Structure/Union member

class arrlibct.c_RGBx

Bases: _ctypes.Structure

b

Structure/Union member

g

Structure/Union member

r

Structure/Union member

class arrlibct.c_HSIx

Bases: _ctypes.Structure

h

Structure/Union member

i

Structure/Union member

s

Structure/Union member

class arrlibct.c_BlobSlice

Bases: _ctypes.Structure

end

Structure/Union member

start

Structure/Union member

class arrlibct.c_BlobChunk

Bases: _ctypes.Structure

firstRow

Structure/Union member

left

Structure/Union member

next

Structure/Union member

right

Structure/Union member

slices

Structure/Union member

class arrlibct.c_BlobHole

Bases: _ctypes.Structure

chunk

Structure/Union member

next

Structure/Union member

class arrlibct.c_BlobSpace

Bases: _ctypes.Structure

chainLevel

Structure/Union member

chunks

Structure/Union member

freeChunks

Structure/Union member

freeHoles

Structure/Union member

holes

Structure/Union member

class arrlibct.c_Blob

Bases: _ctypes.Structure

area

Structure/Union member

blobSpace

Structure/Union member

box

Structure/Union member

chunks

Structure/Union member

holes

Structure/Union member

nChunks

Structure/Union member

nHoles

Structure/Union member

class arrlibct.c_Histogram

Bases: _ctypes.Structure

binSize

Structure/Union member

bins

Structure/Union member

invBinSize

Structure/Union member

nBins

Structure/Union member

sum

Structure/Union member

xMax

Structure/Union member

xMin

Structure/Union member

arrlibct.newVec(t, n)
arrlibct.newMatr(t, m, n)
arrlibct.makeArrOrNone(A)
arrlibct.concat(fmt, *args)
arrlibct.pathTracker2(candidates)

candidates: float** returns: uint*

arrlibct.cycPathTracker2(candidates)

candidates: float** returns: uint*

arrlibct.pathTracker3(candidates)

candidates: float** returns: uint*

arrlibct.multiPathTracker2(candidates, nPaths)

candidates: float** nPaths: uint returns: uint**

arrlibct.moveArrToOtherArrState(A, otherArrState)

A: arr otherArrState: ArrState * returns: arr

arrlibct.moveArrTreeToOtherArrState(A, otherArrState)

A: arr otherArrState: ArrState * returns: arr

class arrlibct.Arr(A, typ=None, own=None)

Bases: object

cast(typ)
pointer()
copy()
own()
prt()
prh()
tag()
toNumpy()
toArrlib()
arrlibct.arrLibVersion()

returns: string

arrlibct.arrLibDate()

returns: string

arrlibct.arrLibGreeting()

returns: void

arrlibct.setLogFunc(logFunc)

logFunc: ArrLogFunc returns: void

arrlibct.setErrMessMax(messMax)

messMax: uint returns: void

arrlibct.setLogMessMax(messMax)

messMax: uint returns: void

arrlibct.setTraceLevelMax(levelMax)

levelMax: uint returns: void

arrlibct.setChainLevelMax(levelMax)

levelMax: uint returns: void

arrlibct.defaultLogFunc(s)

s: string returns: void

arrlibct.logFunc(s)

s: char* returns: void

arrlibct.printArrHead(p)

p: arr returns: void

arrlibct.printArr(A)

A: arr returns: void

arrlibct.defaultErrFunc(errStr, errMess)

errStr: string errMess: string returns: void

arrlibct.doErr(errStr, func, line)

errStr: string func: string line: uint returns: void

arrlibct.errStr()

returns: string

arrlibct.errMess()

returns: string

arrlibct.clearErr()

returns: void

arrlibct.setDebugTrace(f, maxLevel)

f: uint maxLevel: uint returns: void

arrlibct.traceEntry(thisFun)

thisFun: string returns: void

arrlibct.printTraceStack()

returns: void

arrlibct.traceExit()

returns: void

arrlibct.currTraceFunc()

returns: string

arrlibct.printChainStack(when)

when: string returns: void

arrlibct.clearTraceStack()

returns: void

arrlibct.getNumberOfAllocatedArrays()

returns: uint

arrlibct.getArrDataPtr(A)

A: arr returns: ptr

arrlibct.setVecSize(A, s)

A: arr s: uint returns: void

arrlibct.getVecSize(A)

A: arr returns: uint

arrlibct.getVecMax(A)

A: arr returns: uint

arrlibct.getRows(A)

A: arr returns: uint

arrlibct.getCols(A)

A: arr returns: uint

arrlibct.getElemType(A)

A: arr returns: TypeDescriptor *

arrlibct.getTypeDescName(T)

T: TypeDescriptor * returns: string

arrlibct.getTypeDescSize(T)

T: TypeDescriptor * returns: uint

arrlibct.getArrTypeName(A)

A: arr returns: string

arrlibct.isArrTypeByName(A, name)

A: arr name: string returns: int

arrlibct.isArr(A)

A: arr returns: int

arrlibct.matrFlag(A)

A: arr returns: uint

arrlibct.getArrTag(A)

A: arr returns: string

arrlibct.getElemStr(T, pElem)

T: TypeDescriptor * pElem: ptr returns: string

arrlibct.getParent(A)

A: arr returns: arr

arrlibct.setParent(A, P)

A: arr P: arr returns: void

arrlibct.isParent(A)

A: arr returns: uint

arrlibct.isOwned(A)

A: arr returns: int

arrlibct.setOwned(A)

A: arr returns: void

arrlibct.isCyclic(A)

A: arr returns: int

arrlibct.setCyclic(A)

A: arr returns: void

arrlibct.setArr(A, c)

A: arr c: uint8 returns: arr

arrlibct.setArrTreeFlags(A, flag, val)

A: arr flag: uint val: uint returns: arr

arrlibct.initChunkyVec(elemType, chunkSize, increasePercent)

elemType: TypeDescriptor * chunkSize: uint increasePercent: uint returns: ChunkyVecState

arrlibct.chunkyVecSize(p)

p: arr returns: uint

arrlibct.packChunkyVec(p)

p: arr returns: arr

arrlibct.delArr(p)

p: arr returns: void

arrlibct.delMarkArrTree(A)

A: arr returns: void

arrlibct.delMarked()

returns: void

arrlibct.delArrTree(A)

A: arr returns: void

arrlibct.indices(iStart, step, iEnd)

iStart: uint step: int iEnd: uint returns: uint*

arrlibct.indicesInRange(I, a, b)

I: uint* a: uint b: uint returns: uint

arrlibct.indexSet(I)

I: uint* returns: uint*

arrlibct.indexSetNot(I, n)

I: uint* n: uint returns: uint*

arrlibct.indexSetOr(I, J)

I: uint* J: uint* returns: uint*

arrlibct.indexSetAnd(I, J)

I: uint* J: uint* returns: uint*

arrlibct.bitSetNot(B)

B: bits* returns: bits*

arrlibct.bitSetOr(B, C)

B: bits* C: bits* returns: bits*

arrlibct.bitSetAnd(B, C)

B: bits* C: bits* returns: bits*

arrlibct.bitSetEqu(B, C)

B: bits* C: bits* returns: bits*

arrlibct.bitSetXor(B, C)

B: bits* C: bits* returns: bits*

arrlibct.countBits(b)

b: bits returns: uint

arrlibct.countBitSet(B)

B: bits* returns: uint

arrlibct.indexSetToBitSet(I)

I: uint* returns: bits*

arrlibct.bitSetToIndexSet(B)

B: bits* returns: uint*

arrlibct.cloneArr(A)

A: arr returns: arr

arrlibct.copyArrData(S, D)

S: arr D: arr returns: arr

arrlibct.resizeVec(V, slack)

V: arr slack: uint returns: arr

arrlibct.transposeMatr(M)

M: arr returns: arr

arrlibct.flipLeftRight(M)

M: arr returns: arr

arrlibct.flipUpDown(M)

M: arr returns: arr

arrlibct.rotateMatr(M, rot)

M: arr rot: uint returns: arr

arrlibct.subVec(V, iStart, size)

V: arr iStart: uint size: uint returns: arr

arrlibct.cycSubVec(V, iStart, size)

V: arr iStart: uint size: uint returns: arr

arrlibct.extractField(A, fieldType, firstField)

A: arr fieldType: TypeDescriptor * firstField: ptr returns: arr

arrlibct.decimateVec(V, iStart, step, iEnd)

V: arr iStart: uint step: int iEnd: uint returns: arr

arrlibct.indexedSubVec(a, idx)

a: arr idx: uint* returns: arr

arrlibct.bitSetSubVec(V, B)

V: arr B: bits* returns: arr

arrlibct.copyToSubVec(src, dst, iDst)

src: arr dst: arr iDst: uint returns: arr

arrlibct.copyToIndexedSubVec(s, a, idx)

s: arr a: arr idx: uint* returns: arr

arrlibct.subMatr(M, b)

M: arr b: Box2i returns: arr

arrlibct.decimateMatr(M, b, rStp, cStp)

M: arr b: Box2i rStp: int cStp: int returns: arr

arrlibct.indexedSubMatr(A, rowIndex, colIndex)

A: arr rowIndex: uint* colIndex: uint* returns: arr

arrlibct.copyToSubMatr(src, dst, r0, c0)

src: arr dst: arr r0: uint c0: uint returns: arr

arrlibct.copyToIndexedSubMatr(S, A, rowIndex, colIndex)

S: arr A: arr rowIndex: uint* colIndex: uint* returns: arr

arrlibct.copyColToVec(src, dst, c)

src: arr dst: arr c: uint returns: arr

arrlibct.rowVec(M, r)

M: arr r: uint returns: arr

arrlibct.colVec(M, c)

M: arr c: uint returns: arr

arrlibct.maskedMatrToVec(M, mask, minimalAllocation)

M: arr mask: uint8** minimalAllocation: uint returns: arr

arrlibct.concatVec(vecs)

vecs: arr returns: arr

arrlibct.arrChain(level)

level: uint returns: arr

arrlibct.newArrChain()

returns: void

arrlibct.unchainArr(A)

A: arr returns: arr

arrlibct.unchainArrTree(A)

A: arr returns: arr

arrlibct.popChainArr()

returns: arr

arrlibct.rechainArr(level)

level: uint returns: arr

arrlibct.keepArr(A)

A: arr returns: arr

arrlibct.ownArr(A)

A: arr returns: arr

arrlibct.deleteUnkept(popChain)

popChain: uint returns: void

arrlibct.clearArrChains(keepTopLevel)

keepTopLevel: uint returns: void

arrlibct.overwrite(A)

A: arr returns: arr

arrlibct.unoverwrite(A)

A: arr returns: arr

arrlibct.arrChild(S, tag)

S: arr* tag: string returns: arr

arrlibct.arrChildPtr(S, tag)

S: arr* tag: string returns: arr *

arrlibct.addArrChild(parent, child)

parent: arr* child: arr returns: arr

arrlibct.unhookChild(child)

child: arr returns: arr

arrlibct.tagArr(A, tag)

A: arr tag: string returns: arr

arrlibct.ownTagArr(A, tag)

A: arr tag: string returns: arr

arrlibct.copyArrTree(A)

A: arr returns: arr

arrlibct.makeParentTree(A)

A: arr returns: arr

arrlibct.breakParentTree(A)

A: arr returns: arr

arrlibct.arrVecElem(A, i)

A: arr i: uint returns: arr

arrlibct.arrMatrElem(A, i, j)

A: arr i: uint j: uint returns: arr

arrlibct.packArrSize(A)

A: arr returns: uint

arrlibct.packArr(A)

A: arr returns: uint8*

arrlibct.saveArr(A, fileName)

A: arr fileName: string returns: void

arrlibct.unpackArr(pack)

pack: uint8* returns: arr

arrlibct.unpackRawBytes(pack, size)

pack: uint8* size: uint returns: arr

arrlibct.loadArr(fileName)

fileName: string returns: arr

arrlibct.vec_char(*args)

Make a vector of char

arrlibct.vec_arr(*args)

Make a vector of arr

arrlibct.vec_ptr(*args)

Make a vector of ptr

arrlibct.vec_short(*args)

Make a vector of short

arrlibct.vec_ushort(*args)

Make a vector of ushort

arrlibct.vec_uchar(*args)

Make a vector of uchar

arrlibct.vec_int(*args)

Make a vector of int

arrlibct.vec_uint(*args)

Make a vector of uint

arrlibct.vec_long(*args)

Make a vector of long

arrlibct.vec_ulong(*args)

Make a vector of ulong

arrlibct.vec_float(*args)

Make a vector of float

arrlibct.vec_double(*args)

Make a vector of double

arrlibct.vec_ldouble(*args)

Make a vector of ldouble

arrlibct.vec_int8(*args)

Make a vector of int8

arrlibct.vec_int16(*args)

Make a vector of int16

arrlibct.vec_int32(*args)

Make a vector of int32

arrlibct.vec_int64(*args)

Make a vector of int64

arrlibct.vec_uint8(*args)

Make a vector of uint8

arrlibct.vec_uint16(*args)

Make a vector of uint16

arrlibct.vec_uint32(*args)

Make a vector of uint32

arrlibct.vec_uint64(*args)

Make a vector of uint64

arrlibct.vec_bits(*args)

Make a vector of bits

arrlibct.vec_fix(*args)

Make a vector of fix

arrlibct.vec_XYi(*args)

Make a vector of XYi

arrlibct.vec_XYZi(*args)

Make a vector of XYZi

arrlibct.vec_XYZWi(*args)

Make a vector of XYZWi

arrlibct.vec_XYu(*args)

Make a vector of XYu

arrlibct.vec_XYZu(*args)

Make a vector of XYZu

arrlibct.vec_XYZWu(*args)

Make a vector of XYZWu

arrlibct.vec_XYf(*args)

Make a vector of XYf

arrlibct.vec_XYZf(*args)

Make a vector of XYZf

arrlibct.vec_XYZWf(*args)

Make a vector of XYZWf

arrlibct.vec_XYZWVf(*args)

Make a vector of XYZWVf

arrlibct.vec_XYd(*args)

Make a vector of XYd

arrlibct.vec_XYZd(*args)

Make a vector of XYZd

arrlibct.vec_XYZWd(*args)

Make a vector of XYZWd

arrlibct.vec_XYZWVd(*args)

Make a vector of XYZWVd

arrlibct.vec_XYx(*args)

Make a vector of XYx

arrlibct.vec_XYZx(*args)

Make a vector of XYZx

arrlibct.vec_XYZWx(*args)

Make a vector of XYZWx

arrlibct.vec_M22f(*args)

Make a vector of M22f

arrlibct.vec_M33f(*args)

Make a vector of M33f

arrlibct.vec_M43f(*args)

Make a vector of M43f

arrlibct.vec_M44f(*args)

Make a vector of M44f

arrlibct.vec_M22d(*args)

Make a vector of M22d

arrlibct.vec_M33d(*args)

Make a vector of M33d

arrlibct.vec_M43d(*args)

Make a vector of M43d

arrlibct.vec_M44d(*args)

Make a vector of M44d

arrlibct.vec_Pose3f(*args)

Make a vector of Pose3f

arrlibct.vec_Pose3d(*args)

Make a vector of Pose3d

arrlibct.vec_Box1i(*args)

Make a vector of Box1i

arrlibct.vec_Box2i(*args)

Make a vector of Box2i

arrlibct.vec_Box3i(*args)

Make a vector of Box3i

arrlibct.vec_Box1f(*args)

Make a vector of Box1f

arrlibct.vec_Box2f(*args)

Make a vector of Box2f

arrlibct.vec_Box3f(*args)

Make a vector of Box3f

arrlibct.vec_Box1d(*args)

Make a vector of Box1d

arrlibct.vec_Box2d(*args)

Make a vector of Box2d

arrlibct.vec_Box3d(*args)

Make a vector of Box3d

arrlibct.vec_Box1x(*args)

Make a vector of Box1x

arrlibct.vec_Box2x(*args)

Make a vector of Box2x

arrlibct.vec_Box3x(*args)

Make a vector of Box3x

arrlibct.vec_Lin2i(*args)

Make a vector of Lin2i

arrlibct.vec_Lin3i(*args)

Make a vector of Lin3i

arrlibct.vec_Lin2f(*args)

Make a vector of Lin2f

arrlibct.vec_Lin3f(*args)

Make a vector of Lin3f

arrlibct.vec_Lin2d(*args)

Make a vector of Lin2d

arrlibct.vec_Lin3d(*args)

Make a vector of Lin3d

arrlibct.vec_Lin2x(*args)

Make a vector of Lin2x

arrlibct.vec_Lin3x(*args)

Make a vector of Lin3x

arrlibct.vec_Cir2f(*args)

Make a vector of Cir2f

arrlibct.vec_Cir3f(*args)

Make a vector of Cir3f

arrlibct.vec_Cir2d(*args)

Make a vector of Cir2d

arrlibct.vec_Cir3d(*args)

Make a vector of Cir3d

arrlibct.vec2i(x, y)

x: int y: int returns: XYi

arrlibct.vec3i(x, y, z)

x: int y: int z: int returns: XYZi

arrlibct.vec4i(x, y, z, w)

x: int y: int z: int w: int returns: XYZWi

arrlibct.vec2u(x, y)

x: uint y: uint returns: XYu

arrlibct.vec3u(x, y, z)

x: uint y: uint z: uint returns: XYZu

arrlibct.vec4u(x, y, z, w)

x: uint y: uint z: uint w: uint returns: XYZWu

arrlibct.vec2f(x, y)

x: float y: float returns: XYf

arrlibct.vec3f(x, y, z)

x: float y: float z: float returns: XYZf

arrlibct.vec4f(x, y, z, w)

x: float y: float z: float w: float returns: XYZWf

arrlibct.vec5f(x, y, z, w, v)

x: float y: float z: float w: float v: float returns: XYZWVf

arrlibct.vec2d(x, y)

x: double y: double returns: XYd

arrlibct.vec3d(x, y, z)

x: double y: double z: double returns: XYZd

arrlibct.vec4d(x, y, z, w)

x: double y: double z: double w: double returns: XYZWd

arrlibct.vec5d(x, y, z, w, v)

x: double y: double z: double w: double v: double returns: XYZWVd

arrlibct.vec2x(x, y)

x: float y: float returns: XYx

arrlibct.vec3x(x, y, z)

x: float y: float z: float returns: XYZx

arrlibct.vec4x(x, y, z, w)

x: float y: float z: float w: float returns: XYZWx

arrlibct.m22f(v1, v2)

v1: XYf v2: XYf returns: M22f

arrlibct.m33f(v1, v2, v3)

v1: XYZf v2: XYZf v3: XYZf returns: M33f

arrlibct.m43f(v1, v2, v3)

v1: XYZWf v2: XYZWf v3: XYZWf returns: M43f

arrlibct.m44f(v1, v2, v3, v4)

v1: XYZWf v2: XYZWf v3: XYZWf v4: XYZWf returns: M44f

arrlibct.m22d(v1, v2)

v1: XYd v2: XYd returns: M22d

arrlibct.m33d(v1, v2, v3)

v1: XYZd v2: XYZd v3: XYZd returns: M33d

arrlibct.m43d(v1, v2, v3)

v1: XYZWd v2: XYZWd v3: XYZWd returns: M43d

arrlibct.m44d(v1, v2, v3, v4)

v1: XYZWd v2: XYZWd v3: XYZWd v4: XYZWd returns: M44d

arrlibct.pose3f(U, t)

U: M33f t: XYZf returns: Pose3f

arrlibct.pose3d(U, t)

U: M33d t: XYZd returns: Pose3d

arrlibct.box1i(min, max)

min: int max: int returns: Box1i

arrlibct.box2i(min, max)

min: XYi max: XYi returns: Box2i

arrlibct.box3i(min, max)

min: XYZi max: XYZi returns: Box3i

arrlibct.box1f(min, max)

min: float max: float returns: Box1f

arrlibct.box2f(min, max)

min: XYf max: XYf returns: Box2f

arrlibct.box3f(min, max)

min: XYZf max: XYZf returns: Box3f

arrlibct.box1d(min, max)

min: double max: double returns: Box1d

arrlibct.box2d(min, max)

min: XYd max: XYd returns: Box2d

arrlibct.box3d(min, max)

min: XYZd max: XYZd returns: Box3d

arrlibct.box1x(min, max)

min: fix max: fix returns: Box1x

arrlibct.box2x(min, max)

min: XYx max: XYx returns: Box2x

arrlibct.box3x(min, max)

min: XYZx max: XYZx returns: Box3x

arrlibct.lin2i(p, v)

p: XYi v: XYi returns: Lin2i

arrlibct.lin3i(p, v)

p: XYZi v: XYZi returns: Lin3i

arrlibct.lin2f(p, v)

p: XYf v: XYf returns: Lin2f

arrlibct.lin3f(p, v)

p: XYZf v: XYZf returns: Lin3f

arrlibct.lin2d(p, v)

p: XYd v: XYd returns: Lin2d

arrlibct.lin3d(p, v)

p: XYZd v: XYZd returns: Lin3d

arrlibct.lin2x(p, v)

p: XYx v: XYx returns: Lin2x

arrlibct.lin3x(p, v)

p: XYZx v: XYZx returns: Lin3x

arrlibct.setRandSeed(v)

v: uint returns: void

arrlibct.randomu(range)

range: uint returns: uint

arrlibct.randomd()

returns: double

arrlibct.randomf()

returns: double

arrlibct.getMatrInterpolationMode()

returns: uint

arrlibct.setMatrInterpolationMode(mode)

mode: uint returns: void

arrlibct.getArrLibMaxThreads()

returns: int

arrlibct.getSizeOfArrState()

returns: uint

arrlibct.findThresholds(A, threshold, edges)

A: float* threshold: float edges: XYf* returns: void

arrlibct.cycFindThresholds(A, threshold, edges)

A: float* threshold: float edges: XYf* returns: void

arrlibct.findPeakValues(A, useLimit, limit, minVal, maxVal)

A: float* useLimit: uint limit: float minVal: float * maxVal: float * returns: void

arrlibct.valleyCenter(A, iBefore, iAfter, clipThreshold, area, wid, mid)

A: float* iBefore: int iAfter: int clipThreshold: float area: float * wid: float * mid: float * returns: float

arrlibct.peakCenter(A, iBefore, iAfter, clipThreshold, area, wid, mid)

A: float* iBefore: int iAfter: int clipThreshold: float area: float * wid: float * mid: float * returns: float

arrlibct.findPeaks(A, threshold, edges)

A: float* threshold: float edges: XYf* returns: void

arrlibct.findPeaks2(A, threshold1, threshold2, edges)

A: float* threshold1: float threshold2: float edges: XYf* returns: void

arrlibct.cycFindPeaks(A, threshold, edges)

A: float* threshold: float edges: XYf* returns: void

arrlibct.normalizeTrace(A, filter, select)

A: float* filter: uint select: int returns: float*

arrlibct.cycNormalizeTrace(A, filter, select)

A: float* filter: uint select: int returns: float*

arrlibct.minTraceLength(filterLen, filterCount, diffCount)

filterLen: int filterCount: int diffCount: int returns: int

arrlibct.traceLineComb(baseLine, start, stop, step)

baseLine: Lin2f start: float stop: float step: float returns: Lin2f*

arrlibct.findEdges(im, traceLine, start, stop, step, wid, smooBase, smooCount, diffCount, normWid, normSel, mode, threshold)

im: arr traceLine: Lin2f* start: float* stop: float* step: float* wid: uint* smooBase: uint* smooCount: uint* diffCount: uint* normWid: uint* normSel: int* mode: uint* threshold: float* returns: XYf**

arrlibct.findEdgesEx(im, traceLines, start, stop, step, wid, smooBase, smooCount, diffCount, mode, polarity, usePThreshold, pThreshold, threshold, thresholds, samples, shift, scaling)

im: arr traceLines: Lin2f* start: float stop: float step: float wid: uint smooBase: uint smooCount: uint diffCount: uint mode: uint polarity: uint usePThreshold: uint pThreshold: float threshold: float thresholds: float* * samples: arr * shift: float * scaling: float * returns: XYf**

arrlibct.findEdgesEx2(im, traceLines, start, stop, step, wid, smooBase, smooCount, diffCount, mode, polarity, usePThreshold, pThreshold, threshold, useMaxThreshold, maxThreshold, thresholds, samples, shift, scaling)

im: arr traceLines: Lin2f* start: float stop: float step: float wid: uint smooBase: uint smooCount: uint diffCount: uint mode: uint polarity: uint usePThreshold: uint pThreshold: float threshold: float useMaxThreshold: uint maxThreshold: float thresholds: float* * samples: arr * shift: float * scaling: float * returns: XYf**

arrlibct.findEdgeSamples(im, traceLine, start, stop, step, wid, smooBase, smooCount, diff, normWid, normSel)

im: uint8** traceLine: Lin2f start: float stop: float step: float wid: uint smooBase: uint smooCount: uint diff: uint normWid: uint normSel: int returns: float**

arrlibct.findPeaks3(filt, A, filtShift, filtScal, rMean, rVar, mode, absThres, relThres, varThres, baseCut, cog, cob, peak, base, baskew, width, area)

filt: float* A: float* filtShift: float filtScal: float rMean: float* rVar: float* mode: string absThres: Box1f relThres: Box1f varThres: Box1f baseCut: float cog: float* cob: float* peak: float* base: float* baskew: float* width: float* area: float* returns: uint

arrlibct.runningMean(A, r)

A: arr r: uint returns: arr

arrlibct.runningVar(A, M, r)

A: arr M: arr r: uint returns: arr

arrlibct.colEdgeFinder(im, bb, smooWid, smooCnt, diffCnt, mode, runRad, baseCut, absThres, relThres, varThres, baseThres, baskewThres, widthThres, areaThres)

im: arr bb: Box2i smooWid: uint smooCnt: uint diffCnt: uint mode: string runRad: uint baseCut: float absThres: Box1f relThres: Box1f varThres: Box1f baseThres: Box1f baskewThres: Box1f widthThres: Box1f areaThres: Box1f returns: arr

arrlibct.colEdgeFinderDynThres(im, bb, smooWid, smooCnt, diffCnt, mode, runRad, baseCut, absThres, relThres, varThres, baseThres, baskewThres, widthThres, areaThres, pThreshold)

im: arr bb: Box2i smooWid: uint smooCnt: uint diffCnt: uint mode: string runRad: uint baseCut: float absThres: Box1f relThres: Box1f varThres: Box1f baseThres: Box1f baskewThres: Box1f widthThres: Box1f areaThres: Box1f pThreshold: float returns: arr

arrlibct.rowEdgeFinder(im, bb, smooWid, smooCnt, diffCnt, mode, runRad, baseCut, absThres, relThres, varThres, baseThres, baskewThres, widthThres, areaThres)

im: arr bb: Box2i smooWid: uint smooCnt: uint diffCnt: uint mode: string runRad: uint baseCut: float absThres: Box1f relThres: Box1f varThres: Box1f baseThres: Box1f baskewThres: Box1f widthThres: Box1f areaThres: Box1f returns: arr

arrlibct.rowEdgeFinderDynThres(im, bb, smooWid, smooCnt, diffCnt, mode, runRad, baseCut, absThres, relThres, varThres, baseThres, baskewThres, widthThres, areaThres, pThreshold)

im: arr bb: Box2i smooWid: uint smooCnt: uint diffCnt: uint mode: string runRad: uint baseCut: float absThres: Box1f relThres: Box1f varThres: Box1f baseThres: Box1f baskewThres: Box1f widthThres: Box1f areaThres: Box1f pThreshold: float returns: arr

arrlibct.omniDirectionalEdgeFinder(im, bb, nDir, traceRad, smooWid, smooCnt, diffCnt, mode, runRad, baseCut, relThres, varThres, widThres)

im: uint8** bb: Box2i nDir: uint traceRad: uint smooWid: uint smooCnt: uint diffCnt: uint mode: string runRad: uint baseCut: float relThres: Box1f varThres: Box1f widThres: Box1f returns: arr

arrlibct.maxGradients(M, roi, stp, smooBase, smooCount, threshold)

M: uint8** roi: Box2i stp: uint smooBase: uint smooCount: uint threshold: float returns: Lin2f*

arrlibct.maxGrad(G, t)

G: arr t: int returns: XYf*

arrlibct.rangeContour(image, startPoint, startDir, range)

image: uint8** startPoint: XYi startDir: int range: Box1i returns: XYf*

arrlibct.warpTracker2f(M)

M: float** returns: XYi*

arrlibct.histAccum(p2, H, A)

p2: uint H: int* A: int* returns: int*

arrlibct.histPercentile(p2, A, percent)

p2: uint A: int* percent: uint returns: uint

arrlibct.edgeMatch3(reference, observed, angleTol, maxIter)

reference: Lin2f* observed: XYf* angleTol: float maxIter: uint returns: M33f

arrlibct.edgeMatch46(reference, observed, degFree)

reference: Lin2f* observed: XYf* degFree: int returns: M33f

arrlibct.edgeMatch(reference, observed, degFree)

reference: Lin2f* observed: XYf* degFree: int returns: M33f

arrlibct.edgeMatch8(reference, observed)

reference: Lin2f* observed: XYf* returns: M33f

arrlibct.combLineFinder(points, nGood, gapMax, risk, fitTolerance, angle, groupDistMin, orientation, radius, cyclic, compTimeMax)

points: XYf** nGood: uint gapMax: uint risk: float fitTolerance: float angle: Box1f groupDistMin: int orientation: XYf radius: float cyclic: uint compTimeMax: float returns: arr

arrlibct.rangeFromGrayCode(black, white, reference, gray, gain)

black: uint8** white: uint8** reference: uint8** gray: uint8*** gain: uint returns: uint8**

arrlibct.pntInPolygon2i(p, plg)

p: XYi plg: XYi* returns: int

arrlibct.pntInPolygon2f(p, plg)

p: XYf plg: XYf* returns: int

arrlibct.imageExtrema(M, threshold, blobSpace)

M: int** threshold: int blobSpace: BlobSpace * returns: arr*

arrlibct.initLogLut16()

returns: void

arrlibct.logMapImage_uint8(image, pixbits)

image: arr pixbits: uint returns: arr

arrlibct.vec_Blob(*args)

Make a vector of Blob

arrlibct.initBlobSpace(b)

b: BlobSpace * returns: void

arrlibct.clearBlobSpace(b)

b: BlobSpace * returns: void

arrlibct.findBlobs(im, roi, lo, hi, connectedness, blobSpace)

im: arr roi: Box2i lo: float hi: float connectedness: uint blobSpace: BlobSpace * returns: Blob*

arrlibct.findBlobsInBlob(im, blob, lo, hi, connectedness, blobSpace)

im: arr blob: Blob lo: float hi: float connectedness: uint blobSpace: BlobSpace * returns: Blob*

arrlibct.blobContour(blob, contourNo)

blob: Blob contourNo: uint returns: XYi*

arrlibct.blobContourSteps(blob, contourNo)

blob: Blob contourNo: uint returns: XYi*

arrlibct.blobPolygon(blob, contourNo)

blob: Blob contourNo: uint returns: XYf*

arrlibct.countBlobChunks(B)

B: Blob returns: uint

arrlibct.countBlobHoles(B)

B: Blob returns: uint

arrlibct.deleteBlob(blob)

blob: Blob * returns: void

arrlibct.deleteBlobs(blobs)

blobs: Blob* returns: void

arrlibct.blobArea(B)

B: Blob returns: uint

arrlibct.blobBox(B)

B: Blob returns: Box2i

arrlibct.blobsBox(blobs)

blobs: Blob* returns: Box2i

arrlibct.blobCenterOfGravity(B, image)

B: Blob image: uint8** returns: XYf

arrlibct.blobCenterOfGravityInt(B, image)

B: Blob image: int** returns: XYf

arrlibct.blobImage(blob, sourceIm, destIm)

blob: Blob sourceIm: arr destIm: arr returns: arr

arrlibct.erodeBlobs(B, nLayers, connectedness, blobSpace)

B: Blob* nLayers: uint connectedness: uint blobSpace: BlobSpace * returns: Blob*

arrlibct.dilateBlobs(B, nLayers, connectedness, blobSpace)

B: Blob* nLayers: uint connectedness: uint blobSpace: BlobSpace * returns: Blob*

arrlibct.skeletBlobs(blobs, connectedness, blobSpace)

blobs: Blob* connectedness: uint blobSpace: BlobSpace * returns: Blob*

arrlibct.morphBlobs(blobs, morph, connectedness, blobSpace)

blobs: Blob* morph: char* connectedness: uint blobSpace: BlobSpace * returns: Blob*

arrlibct.blobsComplement(blobs, box, connectedness, blobSpace)

blobs: Blob* box: Box2i connectedness: uint blobSpace: BlobSpace * returns: Blob*

arrlibct.blobUnion(A, B, connectedness, blobSpace)

A: Blob* B: Blob* connectedness: uint blobSpace: BlobSpace * returns: Blob*

arrlibct.blobIntersection(A, B, connectedness, blobSpace)

A: Blob* B: Blob* connectedness: uint blobSpace: BlobSpace * returns: Blob*

arrlibct.blobSubtraction(A, B, connectedness, blobSpace)

A: Blob* B: Blob* connectedness: uint blobSpace: BlobSpace * returns: Blob*

arrlibct.setPolygonBlobMethod(method)

method: uint returns: void

arrlibct.getPolygonBlobMethod()

returns: uint

arrlibct.polygonBlob(polygon, blobSpace)

polygon: arr blobSpace: BlobSpace * returns: Blob*

arrlibct.scanSlice(bytes, offset, len, t1, t2, invert, edges)

bytes: uint8 * offset: uint len: uint t1: int t2: int invert: int edges: int * returns: int

arrlibct.decomposeBlob(B)

B: Blob returns: arr

arrlibct.pntInBlob(p, b)

p: XYi b: Blob * returns: int

arrlibct.paintBlobs(M, blobs, v)

M: uint8** blobs: Blob* v: int returns: void

arrlibct.paintBlobs_float(M, blobs, v)

M: float** blobs: Blob* v: float returns: void

arrlibct.filterFIRInBlob(blobs, im, dst, filter, offset)

blobs: Blob* im: arr dst: arr filter: float** offset: float returns: arr

arrlibct.filterEnergyInBlob(blobs, im, dst, I, F, modifyCount)

blobs: Blob* im: arr dst: arr I: int* F: float* modifyCount: int * returns: arr

arrlibct.hom22f(M)

M: M22f returns: M33f

arrlibct.hom33f(M)

M: M33f returns: M44f

arrlibct.ortho22f(v)

v: XYf returns: M22f

arrlibct.ortho22vf(v)

v: XYf returns: M22f

arrlibct.ortho33vvf(v1, v2)

v1: XYZf v2: XYZf returns: M33f

arrlibct.ortho33vf(axis, v)

axis: uint v: XYZf returns: M33f

arrlibct.hom22d(M)

M: M22d returns: M33d

arrlibct.hom33d(M)

M: M33d returns: M44d

arrlibct.ortho22vd(v)

v: XYd returns: M22d

arrlibct.ortho33vvd(v1, v2)

v1: XYZd v2: XYZd returns: M33d

arrlibct.ortho33vd(axis, v)

axis: uint v: XYZd returns: M33d

arrlibct.transp22f(A)

A: M22f returns: M22f

arrlibct.transp33f(A)

A: M33f returns: M33f

arrlibct.transp44f(A)

A: M44f returns: M44f

arrlibct.transp22d(A)

A: M22d returns: M22d

arrlibct.transp33d(A)

A: M33d returns: M33d

arrlibct.transp44d(A)

A: M44d returns: M44d

arrlibct.add22f(A, B)

A: M22f B: M22f returns: M22f

arrlibct.add22d(A, B)

A: M22d B: M22d returns: M22d

arrlibct.add33f(A, B)

A: M33f B: M33f returns: M33f

arrlibct.add33d(A, B)

A: M33d B: M33d returns: M33d

arrlibct.add43f(A, B)

A: M43f B: M43f returns: M43f

arrlibct.add43d(A, B)

A: M43d B: M43d returns: M43d

arrlibct.add44f(A, B)

A: M44f B: M44f returns: M44f

arrlibct.add44d(A, B)

A: M44d B: M44d returns: M44d

arrlibct.sub22f(A, B)

A: M22f B: M22f returns: M22f

arrlibct.sub22d(A, B)

A: M22d B: M22d returns: M22d

arrlibct.sub33f(A, B)

A: M33f B: M33f returns: M33f

arrlibct.sub33d(A, B)

A: M33d B: M33d returns: M33d

arrlibct.sub43f(A, B)

A: M43f B: M43f returns: M43f

arrlibct.sub43d(A, B)

A: M43d B: M43d returns: M43d

arrlibct.sub44f(A, B)

A: M44f B: M44f returns: M44f

arrlibct.sub44d(A, B)

A: M44d B: M44d returns: M44d

arrlibct.mul22f(A, B)

A: M22f B: M22f returns: M22f

arrlibct.mul33f(A, B)

A: M33f B: M33f returns: M33f

arrlibct.mul44f(A, B)

A: M44f B: M44f returns: M44f

arrlibct.mul43f(A, B)

A: M43f B: M43f returns: M43f

arrlibct.mul2x22f(a, B)

a: XYf B: M22f returns: XYf

arrlibct.mulLin2x22f(l, M)

l: Lin2f M: M22f returns: Lin2f

arrlibct.mulLin3x43f(l, M)

l: Lin3f M: M43f returns: Lin3f

arrlibct.mul3x33f(a, B)

a: XYZf B: M33f returns: XYZf

arrlibct.mul4x44f(a, B)

a: XYZWf B: M44f returns: XYZWf

arrlibct.mul4x43f(a, B)

a: XYZWf B: M43f returns: XYZf

arrlibct.mul3x43f(a, B)

a: XYZf B: M43f returns: XYZf

arrlibct.mulNormal3x33f(v, H)

v: XYZf H: M33f returns: XYZf

arrlibct.mulNormal4x44f(v, H)

v: XYZWf H: M44f returns: XYZWf

arrlibct.mul22d(A, B)

A: M22d B: M22d returns: M22d

arrlibct.mul33d(A, B)

A: M33d B: M33d returns: M33d

arrlibct.mul44d(A, B)

A: M44d B: M44d returns: M44d

arrlibct.mul43d(A, B)

A: M43d B: M43d returns: M43d

arrlibct.mul2x22d(a, B)

a: XYd B: M22d returns: XYd

arrlibct.mul3x33d(a, B)

a: XYZd B: M33d returns: XYZd

arrlibct.mul4x44d(a, B)

a: XYZWd B: M44d returns: XYZWd

arrlibct.mul4x43d(a, B)

a: XYZWd B: M43d returns: XYZd

arrlibct.mul3x43d(a, B)

a: XYZd B: M43d returns: XYZd

arrlibct.mulLin3x43d(l, M)

l: Lin3d M: M43d returns: Lin3d

arrlibct.mulNormal3x33d(v, H)

v: XYZd H: M33d returns: XYZd

arrlibct.mulNormal4x44d(v, H)

v: XYZWd H: M44d returns: XYZWd

arrlibct.mul1x22f(f, A)

f: float A: M22f returns: M22f

arrlibct.mul1x33f(f, A)

f: float A: M33f returns: M33f

arrlibct.mul1x44f(f, A)

f: float A: M44f returns: M44f

arrlibct.mul1x22d(d, A)

d: double A: M22d returns: M22d

arrlibct.mul1x33d(d, A)

d: double A: M33d returns: M33d

arrlibct.mul1x44d(d, A)

d: double A: M44d returns: M44d

arrlibct.inv22f(A)

A: M22f returns: M22f

arrlibct.inv33f(A)

A: M33f returns: M33f

arrlibct.inv44f(A)

A: M44f returns: M44f

arrlibct.inv43f(A)

A: M43f returns: M43f

arrlibct.inv22d(A)

A: M22d returns: M22d

arrlibct.inv33d(A)

A: M33d returns: M33d

arrlibct.inv44d(A)

A: M44d returns: M44d

arrlibct.inv43d(A)

A: M43d returns: M43d

arrlibct.det22f(A)

A: M22f returns: float

arrlibct.det33f(A)

A: M33f returns: float

arrlibct.det44f(A)

A: M44f returns: float

arrlibct.det22d(A)

A: M22d returns: double

arrlibct.det33d(A)

A: M33d returns: double

arrlibct.det44d(A)

A: M44d returns: double

arrlibct.zeroExtend2f(v)

v: XYf returns: XYZf

arrlibct.zeroExtend2d(v)

v: XYd returns: XYZd

arrlibct.zeroExtend(V)

V: arr returns: arr

arrlibct.add2i(p, q)

p: XYi q: XYi returns: XYi

arrlibct.sub2i(p, q)

p: XYi q: XYi returns: XYi

arrlibct.add3i(p, q)

p: XYZi q: XYZi returns: XYZi

arrlibct.sub3i(p, q)

p: XYZi q: XYZi returns: XYZi

arrlibct.add4i(p, q)

p: XYZWi q: XYZWi returns: XYZWi

arrlibct.sub4i(p, q)

p: XYZWi q: XYZWi returns: XYZWi

arrlibct.neg2i(p)

p: XYi returns: XYi

arrlibct.neg3i(p)

p: XYZi returns: XYZi

arrlibct.neg4i(p)

p: XYZWi returns: XYZWi

arrlibct.neg2f(p)

p: XYf returns: XYf

arrlibct.add2f(p, q)

p: XYf q: XYf returns: XYf

arrlibct.sub2f(p, q)

p: XYf q: XYf returns: XYf

arrlibct.mul2f(p, q)

p: XYf q: XYf returns: XYf

arrlibct.div2f(p, q)

p: XYf q: XYf returns: XYf

arrlibct.sum2f(p)

p: XYf returns: float

arrlibct.dot2f(u, v)

u: XYf v: XYf returns: float

arrlibct.vecLen2f(v)

v: XYf returns: float

arrlibct.unitVec2f(v)

v: XYf returns: XYf

arrlibct.normalVec2f(v)

v: XYf returns: XYf

arrlibct.neg2d(p)

p: XYd returns: XYd

arrlibct.add2d(p, q)

p: XYd q: XYd returns: XYd

arrlibct.sub2d(p, q)

p: XYd q: XYd returns: XYd

arrlibct.mul2d(p, q)

p: XYd q: XYd returns: XYd

arrlibct.div2d(p, q)

p: XYd q: XYd returns: XYd

arrlibct.sum2d(p)

p: XYd returns: double

arrlibct.dot2d(u, v)

u: XYd v: XYd returns: double

arrlibct.vecLen2d(v)

v: XYd returns: double

arrlibct.unitVec2d(v)

v: XYd returns: XYd

arrlibct.normalVec2d(v)

v: XYd returns: XYd

arrlibct.pntDistance2f(p, q)

p: XYf q: XYf returns: float

arrlibct.angleVec2f(angle)

angle: float returns: XYf

arrlibct.vecAngle2f(v)

v: XYf returns: float

arrlibct.vecAngleDiff2f(u, v)

u: XYf v: XYf returns: float

arrlibct.vecAngleDiff3f(u, v)

u: XYZf v: XYZf returns: float

arrlibct.middleNormal2f(l)

l: Lin2f returns: Lin2f

arrlibct.normalLin2f(l)

l: Lin2f returns: Lin2f

arrlibct.pntToLin2f(p, q)

p: XYf q: XYf returns: Lin2f

arrlibct.linPnt2f(l, t)

l: Lin2f t: float returns: XYf

arrlibct.linEnd2f(l)

l: Lin2f returns: XYf

arrlibct.linIntersectLin2f(k, l, p)

k: Lin2f l: Lin2f p: XYf * returns: float

arrlibct.nearestPntOnLin2f(p, l)

p: XYf l: Lin2f returns: float

arrlibct.linToHomlin2f(l)

l: Lin2f returns: XYZf

arrlibct.pntToHomlin2f(p, q)

p: XYf q: XYf returns: XYZf

arrlibct.normalizeHomlin2f(h)

h: XYZf returns: XYZf

arrlibct.normalizeLin2f(l)

l: Lin2f returns: Lin2f

arrlibct.homlinToLin2f(h)

h: XYZf returns: Lin2f

arrlibct.bisectAcuteHomlin2f(l1, l2)

l1: XYZf l2: XYZf returns: XYZf

arrlibct.bisectObtuseHomlin2f(l1, l2)

l1: XYZf l2: XYZf returns: XYZf

arrlibct.resizeLin2f(l, start, stop)

l: Lin2f start: float stop: float returns: Lin2f

arrlibct.pntDistance2d(p, q)

p: XYd q: XYd returns: double

arrlibct.angleVec2d(angle)

angle: double returns: XYd

arrlibct.vecAngle2d(v)

v: XYd returns: double

arrlibct.vecAngleDiff2d(u, v)

u: XYd v: XYd returns: double

arrlibct.vecAngleDiff3d(u, v)

u: XYZd v: XYZd returns: double

arrlibct.middleNormal2d(l)

l: Lin2d returns: Lin2d

arrlibct.normalLin2d(l)

l: Lin2d returns: Lin2d

arrlibct.pntToLin2d(p, q)

p: XYd q: XYd returns: Lin2d

arrlibct.linPnt2d(l, t)

l: Lin2d t: double returns: XYd

arrlibct.linEnd2d(l)

l: Lin2d returns: XYd

arrlibct.linIntersectLin2d(k, l, p)

k: Lin2d l: Lin2d p: XYd * returns: double

arrlibct.nearestPntOnLin2d(p, l)

p: XYd l: Lin2d returns: double

arrlibct.linToHomlin2d(l)

l: Lin2d returns: XYZd

arrlibct.pntToHomlin2d(p, q)

p: XYd q: XYd returns: XYZd

arrlibct.normalizeHomlin2d(h)

h: XYZd returns: XYZd

arrlibct.normalizeLin2d(l)

l: Lin2d returns: Lin2d

arrlibct.homlinToLin2d(h)

h: XYZd returns: Lin2d

arrlibct.bisectAcuteHomlin2d(l1, l2)

l1: XYZd l2: XYZd returns: XYZd

arrlibct.bisectObtuseHomlin2d(l1, l2)

l1: XYZd l2: XYZd returns: XYZd

arrlibct.resizeLin2d(l, start, stop)

l: Lin2d start: double stop: double returns: Lin2d

arrlibct.neg3f(p)

p: XYZf returns: XYZf

arrlibct.add3f(p, q)

p: XYZf q: XYZf returns: XYZf

arrlibct.sub3f(p, q)

p: XYZf q: XYZf returns: XYZf

arrlibct.mul3f(p, q)

p: XYZf q: XYZf returns: XYZf

arrlibct.div3f(p, q)

p: XYZf q: XYZf returns: XYZf

arrlibct.sum3f(p)

p: XYZf returns: float

arrlibct.dot3f(u, v)

u: XYZf v: XYZf returns: float

arrlibct.vecLen3f(v)

v: XYZf returns: float

arrlibct.unitVec3f(v)

v: XYZf returns: XYZf

arrlibct.pntDistance3f(p, q)

p: XYZf q: XYZf returns: float

arrlibct.cross2f(u, v)

u: XYf v: XYf returns: float

arrlibct.cross3f(u, v)

u: XYZf v: XYZf returns: XYZf

arrlibct.pntToLin3f(p, q)

p: XYZf q: XYZf returns: Lin3f

arrlibct.linPnt3f(l, t)

l: Lin3f t: float returns: XYZf

arrlibct.linEnd3f(l)

l: Lin3f returns: XYZf

arrlibct.linIntersectLin3f(k, l, p, s)

k: Lin3f l: Lin3f p: XYf * s: Lin3f * returns: float

arrlibct.nearestPntOnLin3f(p, l)

p: XYZf l: Lin3f returns: float

arrlibct.normalizeLin3f(l)

l: Lin3f returns: Lin3f

arrlibct.neg3d(p)

p: XYZd returns: XYZd

arrlibct.add3d(p, q)

p: XYZd q: XYZd returns: XYZd

arrlibct.sub3d(p, q)

p: XYZd q: XYZd returns: XYZd

arrlibct.mul3d(p, q)

p: XYZd q: XYZd returns: XYZd

arrlibct.div3d(p, q)

p: XYZd q: XYZd returns: XYZd

arrlibct.sum3d(p)

p: XYZd returns: double

arrlibct.dot3d(u, v)

u: XYZd v: XYZd returns: double

arrlibct.vecLen3d(v)

v: XYZd returns: double

arrlibct.unitVec3d(v)

v: XYZd returns: XYZd

arrlibct.pntDistance3d(p, q)

p: XYZd q: XYZd returns: double

arrlibct.cross2d(u, v)

u: XYd v: XYd returns: double

arrlibct.cross3d(u, v)

u: XYZd v: XYZd returns: XYZd

arrlibct.pntToLin3d(p, q)

p: XYZd q: XYZd returns: Lin3d

arrlibct.linPnt3d(l, t)

l: Lin3d t: double returns: XYZd

arrlibct.linEnd3d(l)

l: Lin3d returns: XYZd

arrlibct.linIntersectLin3d(k, l, p, s)

k: Lin3d l: Lin3d p: XYd * s: Lin3d * returns: double

arrlibct.nearestPntOnLin3d(p, l)

p: XYZd l: Lin3d returns: double

arrlibct.normalizeLin3d(l)

l: Lin3d returns: Lin3d

arrlibct.neg4f(p)

p: XYZWf returns: XYZWf

arrlibct.add4f(p, q)

p: XYZWf q: XYZWf returns: XYZWf

arrlibct.sub4f(p, q)

p: XYZWf q: XYZWf returns: XYZWf

arrlibct.mul4f(p, q)

p: XYZWf q: XYZWf returns: XYZWf

arrlibct.div4f(p, q)

p: XYZWf q: XYZWf returns: XYZWf

arrlibct.sum4f(p)

p: XYZWf returns: float

arrlibct.dot4f(u, v)

u: XYZWf v: XYZWf returns: float

arrlibct.neg4d(p)

p: XYZWd returns: XYZWd

arrlibct.add4d(p, q)

p: XYZWd q: XYZWd returns: XYZWd

arrlibct.sub4d(p, q)

p: XYZWd q: XYZWd returns: XYZWd

arrlibct.mul4d(p, q)

p: XYZWd q: XYZWd returns: XYZWd

arrlibct.div4d(p, q)

p: XYZWd q: XYZWd returns: XYZWd

arrlibct.sum4d(p)

p: XYZWd returns: double

arrlibct.dot4d(u, v)

u: XYZWd v: XYZWd returns: double

arrlibct.mulTransp3x33f(a, B)

a: XYZf B: M33f returns: XYZf

arrlibct.pointPose3f(p, Q)

p: XYZf Q: Pose3f returns: XYZf

arrlibct.posePose3f(Q1, Q2)

Q1: Pose3f Q2: Pose3f returns: Pose3f

arrlibct.linPose3f(l, Q)

l: Lin3f Q: Pose3f returns: Lin3f

arrlibct.planePose3f(l, Q)

l: XYZWf Q: Pose3f returns: XYZWf

arrlibct.invPose3f(Q)

Q: Pose3f returns: Pose3f

arrlibct.pointInvPose3f(p, Q)

p: XYZf Q: Pose3f returns: XYZf

arrlibct.linInvPose3f(l, Q)

l: Lin3f Q: Pose3f returns: Lin3f

arrlibct.planeInvPose3f(l, Q)

l: XYZWf Q: Pose3f returns: XYZWf

arrlibct.mulTransp3x33d(a, B)

a: XYZd B: M33d returns: XYZd

arrlibct.pointPose3d(p, Q)

p: XYZd Q: Pose3d returns: XYZd

arrlibct.posePose3d(Q1, Q2)

Q1: Pose3d Q2: Pose3d returns: Pose3d

arrlibct.linPose3d(l, Q)

l: Lin3d Q: Pose3d returns: Lin3d

arrlibct.planePose3d(l, Q)

l: XYZWd Q: Pose3d returns: XYZWd

arrlibct.invPose3d(Q)

Q: Pose3d returns: Pose3d

arrlibct.pointInvPose3d(p, Q)

p: XYZd Q: Pose3d returns: XYZd

arrlibct.linInvPose3d(l, Q)

l: Lin3d Q: Pose3d returns: Lin3d

arrlibct.planeInvPose3d(l, Q)

l: XYZWd Q: Pose3d returns: XYZWd

arrlibct.xlat2f(p)

p: XYf returns: M33f

arrlibct.xlat3f(p)

p: XYZf returns: M44f

arrlibct.scal2f(s)

s: XYf returns: M33f

arrlibct.scal3f(s)

s: XYZf returns: M44f

arrlibct.scal33f(s)

s: XYZf returns: M33f

arrlibct.xlat43f(t)

t: XYZf returns: M43f

arrlibct.scal43f(s)

s: XYZf returns: M43f

arrlibct.rotx33f(a)

a: float returns: M33f

arrlibct.roty33f(a)

a: float returns: M33f

arrlibct.rotz33f(a)

a: float returns: M33f

arrlibct.rot33f(a)

a: XYZf returns: M33f

arrlibct.rotx43f(a)

a: float returns: M43f

arrlibct.roty43f(a)

a: float returns: M43f

arrlibct.rotz43f(a)

a: float returns: M43f

arrlibct.rot43f(a)

a: XYZf returns: M43f

arrlibct.vecRotz33f(v)

v: XYf returns: M33f

arrlibct.xlat2d(p)

p: XYd returns: M33d

arrlibct.xlat3d(p)

p: XYZd returns: M44d

arrlibct.scal2d(s)

s: XYd returns: M33d

arrlibct.scal3d(s)

s: XYZd returns: M44d

arrlibct.scal33d(s)

s: XYZd returns: M33d

arrlibct.xlat43d(t)

t: XYZd returns: M43d

arrlibct.scal43d(s)

s: XYZd returns: M43d

arrlibct.rotx33d(a)

a: double returns: M33d

arrlibct.roty33d(a)

a: double returns: M33d

arrlibct.rotz33d(a)

a: double returns: M33d

arrlibct.rot33d(a)

a: XYZd returns: M33d

arrlibct.rotx43d(a)

a: double returns: M43d

arrlibct.roty43d(a)

a: double returns: M43d

arrlibct.rotz43d(a)

a: double returns: M43d

arrlibct.rot43d(a)

a: XYZd returns: M43d

arrlibct.vecRotz33d(v)

v: XYd returns: M33d

arrlibct.hom2f(v)

v: XYf returns: XYZf

arrlibct.hom3f(v)

v: XYZf returns: XYZWf

arrlibct.hom2d(v)

v: XYd returns: XYZd

arrlibct.hom3d(v)

v: XYZd returns: XYZWd

arrlibct.unhom2f(h)

h: XYZf returns: XYf

arrlibct.unhom3f(h)

h: XYZWf returns: XYZf

arrlibct.unhom2d(h)

h: XYZd returns: XYd

arrlibct.unhom3d(h)

h: XYZWd returns: XYZd

arrlibct.hom(V)

V: arr returns: arr

arrlibct.unhom(V)

V: arr returns: arr

arrlibct.mul2x33f(v, H)

v: XYf H: M33f returns: XYf

arrlibct.mul3x44f(v, H)

v: XYZf H: M44f returns: XYZf

arrlibct.mul2x33d(v, H)

v: XYd H: M33d returns: XYd

arrlibct.mul3x44d(v, H)

v: XYZd H: M44d returns: XYZd

arrlibct.muln2x33f(v, H)

v: XYf H: M33f returns: XYf

arrlibct.muln3x44f(v, H)

v: XYZf H: M44f returns: XYZf

arrlibct.muln2x33d(v, H)

v: XYd H: M33d returns: XYd

arrlibct.muln3x44d(v, H)

v: XYZd H: M44d returns: XYZd

arrlibct.mulLin2x33f(l, H)

l: Lin2f H: M33f returns: Lin2f

arrlibct.mulLin3x44f(l, H)

l: Lin3f H: M44f returns: Lin3f

arrlibct.mulLin2x33d(l, H)

l: Lin2d H: M33d returns: Lin2d

arrlibct.mulLin3x44d(l, H)

l: Lin3d H: M44d returns: Lin3d

arrlibct.box2iToBox2f(b)

b: Box2i returns: Box2f

arrlibct.box2fToBox2i(b)

b: Box2f returns: Box2i

arrlibct.inBox1i(p, b)

p: int b: Box1i returns: uint

arrlibct.inBox1f(p, b)

p: float b: Box1f returns: uint

arrlibct.inBox1d(p, b)

p: double b: Box1d returns: uint

arrlibct.boxInBox1i(A, B)

A: Box1i B: Box1i returns: uint

arrlibct.boxInBox1f(A, B)

A: Box1f B: Box1f returns: uint

arrlibct.boxInBox1d(A, B)

A: Box1d B: Box1d returns: uint

arrlibct.inBox2i(p, b)

p: XYi b: Box2i returns: uint

arrlibct.inBox2f(p, b)

p: XYf b: Box2f returns: uint

arrlibct.inBox2d(p, b)

p: XYd b: Box2d returns: uint

arrlibct.inBox3i(p, b)

p: XYZi b: Box3i returns: uint

arrlibct.inBox3f(p, b)

p: XYZf b: Box3f returns: uint

arrlibct.inBox3d(p, b)

p: XYZd b: Box3d returns: uint

arrlibct.boxInBox2i(A, B)

A: Box2i B: Box2i returns: uint

arrlibct.boxInBox2f(A, B)

A: Box2f B: Box2f returns: uint

arrlibct.boxInBox2d(A, B)

A: Box2d B: Box2d returns: uint

arrlibct.boxInBox3i(A, B)

A: Box3i B: Box3i returns: uint

arrlibct.boxInBox3f(A, B)

A: Box3f B: Box3f returns: uint

arrlibct.boxInBox3d(A, B)

A: Box3d B: Box3d returns: uint

arrlibct.isEmptyBox1i(b)

b: Box1i returns: uint

arrlibct.isEmptyBox1f(b)

b: Box1f returns: uint

arrlibct.isEmptyBox1d(b)

b: Box1d returns: uint

arrlibct.isEmptyBox2i(b)

b: Box2i returns: uint

arrlibct.isEmptyBox2f(b)

b: Box2f returns: uint

arrlibct.isEmptyBox2d(b)

b: Box2d returns: uint

arrlibct.isEmptyBox3i(b)

b: Box3i returns: uint

arrlibct.isEmptyBox3f(b)

b: Box3f returns: uint

arrlibct.isEmptyBox3d(b)

b: Box3d returns: uint

arrlibct.unionBox2i(b1, b2)

b1: Box2i b2: Box2i returns: Box2i

arrlibct.unionBox2f(b1, b2)

b1: Box2f b2: Box2f returns: Box2f

arrlibct.unionBox2d(b1, b2)

b1: Box2d b2: Box2d returns: Box2d

arrlibct.unionBox3i(b1, b2)

b1: Box3i b2: Box3i returns: Box3i

arrlibct.unionBox3f(b1, b2)

b1: Box3f b2: Box3f returns: Box3f

arrlibct.unionBox3d(b1, b2)

b1: Box3d b2: Box3d returns: Box3d

arrlibct.intersectBox2i(b1, b2)

b1: Box2i b2: Box2i returns: Box2i

arrlibct.intersectBox2f(b1, b2)

b1: Box2f b2: Box2f returns: Box2f

arrlibct.intersectBox2d(b1, b2)

b1: Box2d b2: Box2d returns: Box2d

arrlibct.intersectBox3i(b1, b2)

b1: Box3i b2: Box3i returns: Box3i

arrlibct.intersectBox3f(b1, b2)

b1: Box3f b2: Box3f returns: Box3f

arrlibct.intersectBox3d(b1, b2)

b1: Box3d b2: Box3d returns: Box3d

arrlibct.erodeBox2i(b, k)

b: Box2i k: int returns: Box2i

arrlibct.erodeBox2f(b, k)

b: Box2f k: float returns: Box2f

arrlibct.erodeBox2d(b, k)

b: Box2d k: double returns: Box2d

arrlibct.erodeBox3i(b, k)

b: Box3i k: int returns: Box3i

arrlibct.erodeBox3f(b, k)

b: Box3f k: float returns: Box3f

arrlibct.erodeBox3d(b, k)

b: Box3d k: double returns: Box3d

arrlibct.dilateBox2i(b, k)

b: Box2i k: int returns: Box2i

arrlibct.dilateBox2f(b, k)

b: Box2f k: float returns: Box2f

arrlibct.dilateBox2d(b, k)

b: Box2d k: double returns: Box2d

arrlibct.dilateBox3i(b, k)

b: Box3i k: int returns: Box3i

arrlibct.dilateBox3f(b, k)

b: Box3f k: float returns: Box3f

arrlibct.dilateBox3d(b, k)

b: Box3d k: int returns: Box3d

arrlibct.pointsInBox2f(points, box, mode)

points: XYf* box: Box2f mode: uint returns: uint*

arrlibct.pointsInBox3f(points, box, mode)

points: XYZf* box: Box3f mode: uint returns: uint*

arrlibct.pointsInBox2d(points, box, mode)

points: XYd* box: Box2d mode: uint returns: uint*

arrlibct.pointsInBox3d(points, box, mode)

points: XYZd* box: Box3d mode: uint returns: uint*

arrlibct.triangleCircum(p1, p2, p3)

p1: XYf p2: XYf p3: XYf returns: Cir2f

arrlibct.polygonBox2f(polygon)

polygon: XYf* returns: Box2f

arrlibct.convexHull2f(p, epsilon)

p: XYf* epsilon: float returns: uint*

arrlibct.minEnclosingRectangle2f(p)

p: XYf* returns: XYf*

arrlibct.polygonSimplify2f(p, tol)

p: XYf* tol: float returns: uint*

arrlibct.polygonCenterOfGravity2f(P)

P: arr returns: XYf

arrlibct.polygonAxes2f(P, pcenter, parea)

P: arr pcenter: XYf * parea: float * returns: XYZf

arrlibct.isConvex(P)

P: arr returns: int

arrlibct.polygonArea2f(P)

P: arr returns: float

arrlibct.polygonPerimeter2f(P)

P: XYf* returns: float

arrlibct.polygonSmooth(P, nIter)

P: arr nIter: uint returns: XYf*

arrlibct.pathSmooth(P, nIter)

P: arr nIter: uint returns: XYf*

arrlibct.regularPolygon2f(n)

n: uint returns: XYf*

arrlibct.polygonEdges2f(plg)

plg: XYf* returns: Lin2f*

arrlibct.polygonNormals2f(plg)

plg: XYf* returns: Lin2f*

arrlibct.polygonAngles2f(plg)

plg: arr returns: float*

arrlibct.chopPolygon2f(plg, maxStep)

plg: XYf* maxStep: float returns: XYf*

arrlibct.stepPolygon2f(plg, count)

plg: XYf* count: int returns: XYf*

arrlibct.stepPolygonNormals2f(plg, count)

plg: XYf* count: int returns: Lin2f*

arrlibct.pathLength2f(P)

P: XYf* returns: float

arrlibct.pathLength3f(P)

P: XYZf* returns: float

arrlibct.chopPath2f(plg, maxStep)

plg: XYf* maxStep: float returns: XYf*

arrlibct.stepPath2f(path, count)

path: XYf* count: int returns: XYf*

arrlibct.isoStepPath2f(path, targetStep, actualStep)

path: XYf* targetStep: float actualStep: float * returns: XYf*

arrlibct.isoStepPath3f(path, targetStep, actualStep)

path: XYZf* targetStep: float actualStep: float * returns: XYZf*

arrlibct.stepPathNormals2f(path, count)

path: XYf* count: int returns: Lin2f*

arrlibct.pathNormals2f(path)

path: XYf* returns: Lin2f*

arrlibct.clipf(x, B)

x: float B: Box1f returns: float

arrlibct.clip2f(p, B)

p: XYf B: Box2f returns: XYf

arrlibct.clipBox2i(A, B)

A: Box2i B: Box2i returns: Box2i

arrlibct.clipBox2f(A, B)

A: Box2f B: Box2f returns: Box2f

arrlibct.clipLin2f(l, B)

l: Lin2f B: Box2f returns: Lin2f

arrlibct.clipLinParam2f(l, B)

l: Lin2f B: Box2f returns: XYf

arrlibct.clipCir2f(c, B)

c: Cir2f B: Box2f returns: Cir2f

arrlibct.clipPolygon2f(plg, B)

plg: XYf* B: Box2f returns: XYf*

arrlibct.clipPaths2f(paths, B)

paths: arr B: Box2f returns: arr

arrlibct.intersectLin3fPlane(line, plane, t)

line: Lin3f plane: XYZWf t: float * returns: float

arrlibct.intersectVec3fPlane(v, plane, t)

v: XYZf plane: XYZWf t: float * returns: float

arrlibct.intersectPinRayPlanef(pinRay, plane, z)

pinRay: XYf plane: XYZWf z: float * returns: float

arrlibct.normalizePlanef(plane)

plane: XYZWf * returns: uint

arrlibct.normalizePlaned(plane)

plane: XYZWd * returns: uint

arrlibct.nearestPointOnPlanef(p, plane, distance)

p: XYZf plane: XYZWf distance: float * returns: XYZf

arrlibct.nearestPointOnPlaned(p, plane, distance)

p: XYZd plane: XYZWd distance: double * returns: XYZd

arrlibct.nearestPointOnNormalizedPlanef(p, plane, distance)

p: XYZf plane: XYZWf distance: float * returns: XYZf

arrlibct.nearestPointOnNormalizedPlaned(p, plane, distance)

p: XYZd plane: XYZWd distance: double * returns: XYZd

arrlibct.planeIntersectPlane3f(a, b, l)

a: XYZWf b: XYZWf l: Lin3f * returns: float

arrlibct.planeIntersectPlane3d(a, b, l)

a: XYZWd b: XYZWd l: Lin3d * returns: double

arrlibct.intersectHomlinCir2f(hl, cir, p1, p2)

hl: XYZf cir: Cir2f p1: XYf * p2: XYf * returns: float

arrlibct.intersectLinCir2f(l, cir, t1, t2)

l: Lin2f cir: Cir2f t1: float * t2: float * returns: double

arrlibct.initFastPolar()

returns: void

arrlibct.fastPolar2i(x, y)

x: int8 y: int8 returns: FastPolar

arrlibct.circleFaults2f(c, plg, maxDist, maxAngle)

c: Cir2f plg: XYf* maxDist: float maxAngle: float returns: arr*

arrlibct.polyFit2f(p, q, order)

p: XYf* q: XYf* order: uint returns: XYf*

arrlibct.polyFit2fdf(p, q, order)

p: XYf* q: XYf* order: uint returns: XYf*

arrlibct.polyVal2f(a, q, order)

a: XYf* q: XYf order: uint returns: XYf

arrlibct.polyDeriv2f(a, q, r, order)

a: XYf* q: XYf r: XYf * order: uint returns: M22f

arrlibct.polyFitf(y, x, order)

y: float* x: float* order: uint returns: float*

arrlibct.polyValf(p, x)

p: float* x: float returns: float

arrlibct.polyDerivf(a, q, r)

a: float* q: float r: float * returns: float

arrlibct.identityMatr(typ, n)

typ: TypeDescriptor * n: uint returns: arr

arrlibct.mulMatr(A, B)

A: arr B: arr returns: arr

arrlibct.leftInverse(A, B)

A: arr B: arr returns: arr

arrlibct.invMatr(A)

A: arr returns: arr

arrlibct.arrMul33f(V, M)

V: arr M: M33f returns: arr

arrlibct.arrMul33d(V, M)

V: arr M: M33d returns: arr

arrlibct.arrMul43f(V, M)

V: arr M: M43f returns: arr

arrlibct.arrMul43d(V, M)

V: arr M: M43d returns: arr

arrlibct.arrMul44f(V, M)

V: arr M: M44f returns: arr

arrlibct.arrMul44d(V, M)

V: arr M: M44d returns: arr

arrlibct.arrMulPose3f(V, M)

V: arr M: Pose3f returns: arr

arrlibct.arrMulPose3d(V, M)

V: arr M: Pose3d returns: arr

arrlibct.robustExtremaf(y, h)

y: float* h: float returns: arr*

arrlibct.robustExtrema(V, hyster)

V: arr hyster: float returns: int*

arrlibct.cycRobustExtrema(V, hyster)

V: arr hyster: float returns: int*

arrlibct.extrema(V)

V: arr returns: XYi*

arrlibct.cycExtrema(V)

V: arr returns: XYi*

arrlibct.uint8ToInt(src, dst, n)

src: uint8* dst: int* n: uint returns: void

arrlibct.floatToInt(src, dst, n)

src: float* dst: int* n: uint returns: void

arrlibct.doubleToInt(src, dst, n)

src: double* dst: int* n: uint returns: void

arrlibct.fixToInt(src, dst, n)

src: fix* dst: int* n: uint returns: void

arrlibct.toInt(A)

A: arr returns: arr

arrlibct.intToUint8(src, dst, n)

src: int* dst: uint8* n: uint returns: void

arrlibct.floatToUint8(src, dst, n)

src: float* dst: uint8* n: uint returns: void

arrlibct.doubleToUint8(src, dst, n)

src: double* dst: uint8* n: uint returns: void

arrlibct.fixToUint8(src, dst, n)

src: fix* dst: uint8* n: uint returns: void

arrlibct.toUint8(A)

A: arr returns: arr

arrlibct.intToFloat(src, dst, n)

src: int* dst: float* n: uint returns: void

arrlibct.uint8ToFloat(src, dst, n)

src: uint8* dst: float* n: uint returns: void

arrlibct.doubleToFloat(src, dst, n)

src: double* dst: float* n: uint returns: void

arrlibct.fixToFloat(src, dst, n)

src: fix* dst: float* n: uint returns: void

arrlibct.toFloat(A)

A: arr returns: arr

arrlibct.intToDouble(src, dst, n)

src: int* dst: double* n: uint returns: void

arrlibct.uint8ToDouble(src, dst, n)

src: uint8* dst: double* n: uint returns: void

arrlibct.floatToDouble(src, dst, n)

src: float* dst: double* n: uint returns: void

arrlibct.fixToDouble(src, dst, n)

src: fix* dst: double* n: uint returns: void

arrlibct.toDouble(A)

A: arr returns: arr

arrlibct.intToFix(src, dst, n)

src: int* dst: fix* n: uint returns: void

arrlibct.uint8ToFix(src, dst, n)

src: uint8* dst: fix* n: uint returns: void

arrlibct.doubleToFix(src, dst, n)

src: double* dst: fix* n: uint returns: void

arrlibct.floatToFix(src, dst, n)

src: float* dst: fix* n: uint returns: void

arrlibct.toFix(A)

A: arr returns: arr

arrlibct.toRGB(A)

A: arr returns: arr

arrlibct.toRGBf(A)

A: arr returns: arr

arrlibct.toRGBx(A)

A: arr returns: arr

arrlibct.toHSI(A)

A: arr returns: arr

arrlibct.toHSIf(A)

A: arr returns: arr

arrlibct.toHSIx(A)

A: arr returns: arr

arrlibct.cmp_gt(A, B)

A: arr B: arr returns: bits*

arrlibct.cmp_ge(A, B)

A: arr B: arr returns: bits*

arrlibct.cmp_le(A, B)

A: arr B: arr returns: bits*

arrlibct.cmp_lt(A, B)

A: arr B: arr returns: bits*

arrlibct.cmp_eq(A, B)

A: arr B: arr returns: bits*

arrlibct.cmp_ne(A, B)

A: arr B: arr returns: bits*

arrlibct.cmp_gt_double(A, B)

A: arr B: double returns: bits*

arrlibct.cmp_ge_double(A, B)

A: arr B: double returns: bits*

arrlibct.cmp_le_double(A, B)

A: arr B: double returns: bits*

arrlibct.cmp_lt_double(A, B)

A: arr B: double returns: bits*

arrlibct.cmp_eq_double(A, B)

A: arr B: double returns: bits*

arrlibct.cmp_ne_double(A, B)

A: arr B: double returns: bits*

arrlibct.sumf(x)

x: float* returns: float

arrlibct.meanf(x)

x: float* returns: float

arrlibct.varf(x)

x: float* returns: float

arrlibct.iMinf(x)

x: float* returns: uint

arrlibct.iMaxf(x)

x: float* returns: uint

arrlibct.minf(x)

x: float* returns: float

arrlibct.maxf(x)

x: float* returns: float

arrlibct.doRowsf(M)

M: ptr* returns: float*

arrlibct.doColsf(M)

M: ptr* returns: float*

arrlibct.sum_XYf(V)

V: XYf* returns: XYf

arrlibct.sum_XYZf(V)

V: XYZf* returns: XYZf

arrlibct.sum_XYZWf(V)

V: XYZWf* returns: XYZWf

arrlibct.sum_XYZWVf(V)

V: XYZWVf* returns: XYZWVf

arrlibct.sum_XYd(V)

V: XYd* returns: XYd

arrlibct.sum_XYZd(V)

V: XYZd* returns: XYZd

arrlibct.sum_XYZWd(V)

V: XYZWd* returns: XYZWd

arrlibct.sum_XYZWVd(V)

V: XYZWVd* returns: XYZWVd

arrlibct.mean_XYf(V)

V: XYf* returns: XYf

arrlibct.mean_XYZf(V)

V: XYZf* returns: XYZf

arrlibct.mean_XYZWf(V)

V: XYZWf* returns: XYZWf

arrlibct.mean_XYZWVf(V)

V: XYZWVf* returns: XYZWVf

arrlibct.mean_XYd(V)

V: XYd* returns: XYd

arrlibct.mean_XYZd(V)

V: XYZd* returns: XYZd

arrlibct.mean_XYZWd(V)

V: XYZWd* returns: XYZWd

arrlibct.mean_XYZWVd(V)

V: XYZWVd* returns: XYZWVd

arrlibct.smooDiff(A, smooBase, smooCount, diffCount, shift, scaling)

A: arr smooBase: uint smooCount: uint diffCount: uint shift: float * scaling: float * returns: arr

arrlibct.smooDiffScal(A, smooBase, smooCount, diffCount, diffScal, shift)

A: arr smooBase: uint smooCount: uint diffCount: uint diffScal: int shift: float * returns: arr

arrlibct.cycSmooDiff(A, smooBase, smooCount, diffCount, shift, scaling)

A: arr smooBase: uint smooCount: uint diffCount: uint shift: float * scaling: float * returns: arr

arrlibct.smooDiffMatr(M, smooBase, smooCount, diffCount, shift, scaling, validSize)

M: arr smooBase: XYi smooCount: XYi diffCount: XYi shift: XYf * scaling: float * validSize: XYi * returns: arr

arrlibct.gradientMatr(M, smooBase, smooCount, shift, scaling)

M: arr smooBase: XYi smooCount: XYi shift: XYf * scaling: float * returns: arr

arrlibct.fastGradMatr(M, mode)

M: uint8** mode: uint returns: arr

arrlibct.rawUint8MatrGradf(M, i, j)

M: uint8** i: uint j: uint returns: XYf

arrlibct.lInterpolatef(Y, x)

Y: float* x: float returns: float

arrlibct.lInterpolateVec(A, X)

A: arr X: float* returns: float*

arrlibct.lInterpolateXYfVec(P, X)

P: XYf* X: float* returns: float*

arrlibct.resampleTrail(trail, axis, step, method, firstIndex)

trail: arr axis: uint step: double method: uint firstIndex: int * returns: float*

arrlibct.rawNearInterpUint8(M, r, c)

M: uint8** r: float c: float returns: float

arrlibct.rawFixNearInterpUint8(M, i, j)

M: uint8** i: fix j: fix returns: fix

arrlibct.rawBilInterpf(M, r, c)

M: float** r: float c: float returns: float

arrlibct.rawBilInterpUint8(M, r, c)

M: uint8** r: float c: float returns: float

arrlibct.rawFixBilInterpUint8(M, i, j)

M: uint8** i: fix j: fix returns: fix

arrlibct.rawFixBilInterpRGB(M, i, j)

M: RGB** i: fix j: fix returns: RGBx

arrlibct.rawBilInterpRGB(M, r, c)

M: RGB** r: float c: float returns: RGBf

arrlibct.rawBilInterpHSI(M, r, c)

M: HSI** r: float c: float returns: HSIf

arrlibct.rawBilInterpGradf(M, r, c)

M: float** r: float c: float returns: XYf

arrlibct.rawBilInterpGradUint8(M, r, c)

M: uint8** r: float c: float returns: XYf

arrlibct.stepLin2f(line, start, stop, step)

line: Lin2f start: float stop: float step: float returns: XYf*

arrlibct.stepLin2x(line, start, stop, step)

line: Lin2x start: float stop: float step: float returns: XYx*

arrlibct.bilInterpolateLin2x(M, line, start, stop, step)

M: arr line: Lin2x start: float stop: float step: float returns: arr

arrlibct.bilInterpolate(M, P)

M: arr P: arr returns: arr

arrlibct.indexBilInterpolate(M, P, I)

M: arr P: arr I: arr returns: arr

arrlibct.unsafeBilInterpolate(M, P)

M: arr P: arr returns: arr

arrlibct.fastBilInterpolate(M, Px, Py, maxThreads)

M: arr Px: float** Py: float** maxThreads: uint returns: arr

arrlibct.bilInterpolateLin2f(M, line, start, stop, step)

M: arr line: Lin2f start: float stop: float step: float returns: arr

arrlibct.bilInterpolateWideLin2f(M, line, start, stop, step, wid)

M: arr line: Lin2f start: float stop: float step: float wid: uint returns: arr

arrlibct.bilInterpolateGradient(M, p)

M: arr p: XYf* returns: XYf*

arrlibct.bilInterpolateWidePath2f(M, path, wid)

M: arr path: XYf* wid: uint returns: arr

arrlibct.bilInterpolateClipWideLin2f_old(M, line, start, stop, step, wid, newStart, newStop)

M: arr line: Lin2f start: float stop: float step: float wid: uint newStart: float * newStop: float * returns: arr

arrlibct.bilInterpolateClipWideLin2f(M, line, start, stop, step, wid, newStart, newStop)

M: arr line: Lin2f start: float stop: float step: float wid: uint newStart: float * newStop: float * returns: arr

arrlibct.bilInterpolateClipLin2f(M, line, start, stop, step, newStart, newStop)

M: arr line: Lin2f start: float stop: float step: float newStart: float * newStop: float * returns: arr

arrlibct.interpolateClipWideLin2f(M, line, start, stop, step, wid, mode, newStart, newStop)

M: arr line: Lin2f start: float stop: float step: float wid: uint mode: uint newStart: float * newStop: float * returns: arr

arrlibct.interpolate_uint8Matr_XYxMatr(M, outside, P, method)

M: uint8** outside: fix P: XYx** method: uint returns: fix**

arrlibct.interpolate_RGBMatr_XYxMatr(M, outside, P, method)

M: RGB** outside: RGBx P: XYx** method: uint returns: RGBx**

arrlibct.histogram(X, W, xmin, xmax, resol)

X: float** W: float** xmin: float xmax: float resol: float returns: float**

arrlibct.histogramQuantile(bins, q)

bins: float** q: float returns: float*

arrlibct.initHistogram(hist, xMin, xMax, maxBinSize)

hist: Histogram * xMin: float xMax: float maxBinSize: float returns: void

arrlibct.reSymEigenvecf(A)

A: float** returns: arr*

arrlibct.reSymEigenvecd(A)

A: double** returns: arr*

arrlibct.numberedPair(k)

k: double returns: XYi

arrlibct.numberedTriple(k)

k: double returns: XYZi

arrlibct.factu(n)

n: uint returns: uint

arrlibct.fact(n)

n: uint returns: double

arrlibct.binomCoeff(n, k)

n: uint k: uint returns: double

arrlibct.logFact(n)

n: double returns: double

arrlibct.logBinomCoeff(n, k)

n: double k: double returns: double

arrlibct.searchRisk(population, nGood, nSearched)

population: double nGood: double nSearched: double returns: double

arrlibct.tupleSearchRisk(all, good, tuple, nSearched)

all: uint good: uint tuple: uint nSearched: double returns: double

arrlibct.searchRiskCount(population, nGood, risk)

population: double nGood: double risk: double returns: uint

arrlibct.tupleSearchRiskCount(all, good, tuple, risk)

all: uint good: uint tuple: uint risk: float returns: uint

arrlibct.permutations(n)

n: uint returns: uint**

arrlibct.orderedSubsets(n, k)

n: uint k: uint returns: uint**

arrlibct.fitLin(X, Y, rms)

X: int* Y: float* rms: float * returns: XYf

arrlibct.fitHomlin(points, rms)

points: XYf* rms: float * returns: XYZf

arrlibct.fitPlane(points, rms)

points: XYZf* rms: float * returns: XYZWf

arrlibct.fitCir(p, approx, rms)

p: XYf* approx: Cir2f rms: float * returns: Cir2f

arrlibct.robustFitHomlin(points, nGoodPoints, risk, fitTolerance, iFit, rms)

points: XYf* nGoodPoints: uint risk: float fitTolerance: float iFit: uint* * rms: float * returns: XYZf

arrlibct.robustFitCir(points, nGoodPoints, radiusActive, minRadius, maxRadius, riskMode, risk, maxCount, matchMode, RMSFactor, fitTolerance, iFit, rms)

points: XYf* nGoodPoints: uint radiusActive: uint minRadius: float maxRadius: float riskMode: int risk: float maxCount: int matchMode: int RMSFactor: float fitTolerance: float iFit: uint* * rms: float * returns: Cir2f

arrlibct.bresenhamLinePoints(p, q, omitLast)

p: XYi q: XYi omitLast: uint returns: XYi*

arrlibct.bresenhamLineIndices(p, q, omitLast, cols)

p: XYi q: XYi omitLast: uint cols: int returns: uint*

arrlibct.drawBresenhamLine(p, q, omitLast, M, setVal)

p: XYi q: XYi omitLast: uint M: uint8** setVal: uint8 returns: uint8**

arrlibct.drawBox(M, b, value)

M: uint8** b: Box2i value: int returns: uint8**

arrlibct.framePoints(b)

b: Box2i returns: XYi*

arrlibct.rectangularSpiralPoints(b)

b: Box2i returns: XYi*

arrlibct.gridPoints(m, n, makeMatr)

m: uint n: uint makeMatr: uint returns: arr

arrlibct.squareSpiralPoints(rounds, step)

rounds: uint step: float returns: XYf*

arrlibct.circularSpiralPoints(rounds, step)

rounds: uint step: float returns: XYf*

arrlibct.annulusSectorPoints(radcount, circount, inradius, outradius, arcstart, arcend)

radcount: uint circount: uint inradius: float outradius: float arcstart: float arcend: float returns: XYf**

arrlibct.concentricAnnularGridPoints(rMax)

rMax: uint returns: XYi**

arrlibct.poly2rootf(a, b, c, x1, x2)

a: float b: float c: float x1: float * x2: float * returns: float

arrlibct.poly2rootd(a, b, c, x1, x2)

a: double b: double c: double x1: double * x2: double * returns: double

arrlibct.poly3rootf(a, b, c, d, x1, x2, x3)

a: float b: float c: float d: float x1: float * x2: float * x3: float * returns: float

arrlibct.poly3rootd(a, b, c, d, x1, x2, x3)

a: double b: double c: double d: double x1: double * x2: double * x3: double * returns: double

arrlibct.randIndex(n)

n: int returns: int

arrlibct.gray2bin(n)

n: uint returns: uint

arrlibct.bin2gray(n)

n: uint returns: uint

arrlibct.crossRatio4d(y1, y2, y3, y4)

y1: double y2: double y3: double y4: double returns: double

arrlibct.crossRatio2d(a, b)

a: double b: double returns: double

arrlibct.zeroCrossingsf(y)

y: float* returns: uint*

arrlibct.sortVec(V)

V: arr returns: arr

arrlibct.indSortVec(V)

V: arr returns: uint*

arrlibct.indSortStructVec(V, fieldType, firstField)

V: arr fieldType: TypeDescriptor * firstField: ptr returns: uint*

arrlibct.sortStructVec(V, fieldType, firstField)

V: arr fieldType: TypeDescriptor * firstField: ptr returns: arr

arrlibct.flipVec(V)

V: arr returns: arr

arrlibct.sortVecRev(V)

V: arr returns: arr

arrlibct.indSortVecRev(V)

V: arr returns: uint*

arrlibct.medianf(V)

V: float* returns: float

arrlibct.selectionFilterVec(V, k, select)

V: float* k: uint select: int returns: float*

arrlibct.percentileFilterMatr_float(M, wr, wc, percentile)

M: float** wr: uint wc: uint percentile: uint returns: float**

arrlibct.medianFilterMatr_float(M, wr, wc)

M: float** wr: uint wc: uint returns: float**

arrlibct.percentileFilterMatr(M, wr, wc, percentile)

M: uint8** wr: uint wc: uint percentile: uint returns: uint8**

arrlibct.medianFilterMatr(M, wr, wc)

M: uint8** wr: uint wc: uint returns: uint8**

arrlibct.windowCount(X, w, sort)

X: float* w: float sort: uint returns: XYi*

arrlibct.cycWindowCount(X, w)

X: uint* w: uint returns: XYi*

arrlibct.hypRectClust(P, wid, nMin)

P: float** wid: float* nMin: uint returns: uint**

arrlibct.cycHypRectClust(P, wid, cyc, nMin)

P: float** wid: float* cyc: float* nMin: uint returns: uint**

arrlibct.propertyRangeFilter(properties, constraints, enable, invert)

properties: arr constraints: Box1f* enable: XYu* invert: uint* returns: uint*

arrlibct.sortGridPoints(p, m, n)

p: XYf* m: uint n: uint returns: XYf*

arrlibct.matchGridPoints(objectPoints, imagePoints, m, n)

objectPoints: XYf* imagePoints: XYf* m: uint n: uint returns: arr

arrlibct.sortedMatchGridPoints(objectPoints, imagePoints, sorted)

objectPoints: XYf* imagePoints: XYf* sorted: int** returns: arr

arrlibct.robustMatchGridPoints(objectPoints, imagePoints, m, n)

objectPoints: XYf* imagePoints: XYf* m: uint n: uint returns: arr

arrlibct.telecentricImObj(objectPoints, imagePoints)

objectPoints: XYf* imagePoints: XYf* returns: M33f

arrlibct.dlt33(objectPoints, imagePoints, imObj, objIm)

objectPoints: XYf* imagePoints: XYf* imObj: M33d * objIm: M33d * returns: double

arrlibct.dlt43(objectPoints, imagePoints, A)

objectPoints: XYZf* imagePoints: XYf* A: M43d * returns: double

arrlibct.dlt(p, q, A)

p: XYZf* q: XYZf* A: M43f * returns: float

arrlibct.decompDlt43d(A)

A: M43d returns: arr

arrlibct.unitaryM33d(M)

M: M33d returns: M33d

arrlibct.unitaryM33f(M)

M: M33f returns: M33f

arrlibct.toEulerf(M, ro)

M: M33f ro: int returns: XYZf

arrlibct.toEulerd(M, ro)

M: M33d ro: int returns: XYZd

arrlibct.findCircularDots(im, ROIbox, smoothing, Sobel, Morphology, threshold, threshold1, threshold2, SearchOutside, mincirc, usemind, usemaxd, mind, maxd)

im: arr ROIbox: Box2i smoothing: uint Sobel: int Morphology: uint8* threshold: float threshold1: float threshold2: float SearchOutside: int mincirc: float usemind: int usemaxd: int mind: float maxd: float returns: XYf*

arrlibct.calibrateGridImage(params)

params: arr returns: arr

arrlibct.calibrateImage1(params)

params: arr returns: arr

arrlibct.setObjToPixCount(count)

count: uint returns: void

arrlibct.getObjToPixCount()

returns: uint

arrlibct.setObjToPixTol(tol)

tol: float returns: void

arrlibct.getObjToPixTol()

returns: float

arrlibct.pixToObj(calib, p, pinObj)

calib: arr* p: arr pinObj: M33f returns: arr

arrlibct.pixToObj2f(calib, p, pinObj)

calib: arr* p: XYf pinObj: M33f returns: XYf

arrlibct.pixToObjLin2f(calib, l, pinObj)

calib: arr l: Lin2f pinObj: M33f returns: Lin2f

arrlibct.objToPix(calib, p, pinObj)

calib: arr* p: arr pinObj: M33f returns: arr

arrlibct.objToPix2f(calib, p, pinObj)

calib: arr p: XYf pinObj: M33f returns: XYf

arrlibct.objToPixLin2f(calib, l, pinObj)

calib: arr l: Lin2f pinObj: M33f returns: Lin2f

arrlibct.initHSLut()

returns: void

arrlibct.setHSLutFileName(fileName)

fileName: string returns: void

arrlibct.saveHSLut()

returns: void

arrlibct.initILut()

returns: void

arrlibct.rgb2hsiSlow(p)

p: RGB returns: HSI

arrlibct.rgb2hsiFast(p)

p: RGB returns: HSI

arrlibct.rgb2hsiMatr(im, maxThreads)

im: RGB** maxThreads: uint returns: HSI**

arrlibct.rgb2hsiMatrDec(im, dec)

im: RGB** dec: XYi returns: HSI**

arrlibct.getHSIPlane(im, plane, maxThreads)

im: HSI** plane: char maxThreads: uint returns: uint8**

arrlibct.make8bitIntensity(im)

im: HSI** returns: HSI**

arrlibct.newColorLut()

returns: uint32*

arrlibct.setColorLutBit(lut, p)

lut: uint32* p: RGB returns: void

arrlibct.getColorLutBit(lut, p)

lut: uint32* p: RGB returns: int

arrlibct.colorBlobs(im, lut, roi, connectedness, filterFunc, blobSpace)

im: RGB** lut: uint32* roi: Box2i connectedness: uint filterFunc: FinishedBlobFunc blobSpace: BlobSpace * returns: Blob*

arrlibct.landmarkTransform(src, tgt, mode, rms)

src: XYZf* tgt: XYZf* mode: int rms: float * returns: M44f

arrlibct.radiusTracker1(candidateEdges, costFuncIndex, totCost)

candidateEdges: arr costFuncIndex: uint totCost: float * returns: uint*

arrlibct.findPaths(edgePos, offset, direction, fitTol)

edgePos: float** offset: float direction: uint fitTol: float returns: XYf**

arrlibct.findIndexPathsWithGapSplicing(edgePos, maxPointsPerScan, fitTol, maxGap)

edgePos: float** maxPointsPerScan: uint fitTol: float maxGap: float returns: XYu**

arrlibct.pathsFromIndexPaths1(edgePos, strength, indPaths, sizeFilt, strengthThreshold, offset, direction)

edgePos: float** strength: float** indPaths: XYu** sizeFilt: Box1i strengthThreshold: float offset: uint direction: uint returns: XYf**

arrlibct.findMultiDirPaths(lines, edgePos, fitTol)

lines: Lin2f** edgePos: float*** fitTol: float returns: XYf***

arrlibct.removeSkewedPaths(paths, maxAngle, spanRad, keepSpan)

paths: XYf*** maxAngle: float spanRad: uint keepSpan: uint returns: XYf***

arrlibct.fitLinPaths(paths, sizeThres, rmsThres, goodFrac, risk, fitTol)

paths: XYf*** sizeThres: Box1i rmsThres: float goodFrac: float risk: float fitTol: float returns: Lin2f**

arrlibct.unitStepXMonotonicPath2f(path, x0)

path: XYf* x0: int * returns: float*

arrlibct.pathColumnNeighborhoodUint8(image, path, start, stop, step)

image: uint8** path: XYf* start: uint stop: uint step: uint returns: uint8**

arrlibct.pathRowNeighborhoodUint8(image, path, start, stop, step)

image: uint8** path: XYf* start: uint stop: uint step: uint returns: uint8**

arrlibct.pathEndChordRect2f(path)

path: XYf* returns: XYZf

arrlibct.pathCurvature2f(path, smooBase, smooCount, resampStep, shift)

path: XYf* smooBase: uint smooCount: uint resampStep: float shift: float * returns: float*

arrlibct.pathTriangCurvature2f(path, smooBase, smooCount, shift)

path: XYf* smooBase: uint smooCount: uint shift: float * returns: float*

arrlibct.pathProperties(paths, curvSmooBase, curvSmooCount)

paths: XYf** curvSmooBase: uint curvSmooCount: uint returns: arr

arrlibct.susanBrightnessDifferenceLUTu8(threshold, power)

threshold: float power: uint8 returns: uint8*

arrlibct.susan77u8(image, diffThres, power, usanThresPercent)

image: uint8** diffThres: uint8 power: uint8 usanThresPercent: uint8 returns: uint8**

arrlibct.susanEdges77u8(image, diffThres, power, usanThresPercent)

image: uint8** diffThres: uint8 power: uint8 usanThresPercent: uint8 returns: uint8**

arrlibct.linXrat(L, I, order)

L: Lin2f* I: uint* order: uint* returns: float

arrlibct.tuneFuzzyLine(image, initLin, perDevMax, perStep, offsetMax, offsetStep, useAbsDiff, smooWid, smooCnt, polarity)

image: uint8** initLin: Lin2f perDevMax: float perStep: float offsetMax: float offsetStep: float useAbsDiff: int smooWid: uint smooCnt: uint polarity: int returns: Lin2f

arrlibct.fineMatchXratSymbol1(image, ribs, symb, vis)

image: uint8** ribs: Lin2f* symb: XYZWf* vis: Lin2f* * returns: M33f

arrlibct.fineMatchXratSymbol2(lines, ribs, symb, barAngMax, barSearch, pos, vis)

lines: Lin2f** ribs: Lin2f* symb: XYZWf* barAngMax: float barSearch: XYf pos: M33f * vis: Lin2f* * returns: int

arrlibct.findXratSymbols(image, traceRad, smooWid, smooCnt, diffCnt, mode, runRad, baseCut, relThres, widThres, chainTol, pthMaxAngle, pthSpanRad, pthKeepSpan, linRmsMax, linGoodFrac, linRisk, linFitTol, linLenBounds, linClustWid, linClustHei, linClustAng, barSearch, barAngle, dupMaxDist, symbDescr, xratTol)

image: uint8** traceRad: uint smooWid: uint smooCnt: uint diffCnt: uint mode: string runRad: uint baseCut: float relThres: Box1f widThres: Box1f chainTol: float pthMaxAngle: float pthSpanRad: uint pthKeepSpan: uint linRmsMax: float linGoodFrac: float linRisk: float linFitTol: float linLenBounds: Box1i linClustWid: float linClustHei: float linClustAng: float barSearch: XYf barAngle: float dupMaxDist: float symbDescr: XYZWf** xratTol: float returns: arr

arrlibct.makePathMatchStructure(aPaths, aStartInd, bPaths, bStartInd)

aPaths: float** aStartInd: int* bPaths: float** bStartInd: int* returns: arr

arrlibct.stereoIntersectTwoPaths(ax0, aPathY, bx0, bPathY, baseLen, xStep, pairToObj, xStart, xEnd)

ax0: int aPathY: float* bx0: int bPathY: float* baseLen: float xStep: float pairToObj: Pose3f xStart: int * xEnd: int * returns: XYZf*

arrlibct.decimateDepthRayGrid(depth, grid, dr, dc, minValidFraction)

depth: float** grid: XYf** dr: uint dc: uint minValidFraction: float returns: arr

arrlibct.depthRayGridToMaskedPointGrid(depth, grid, toCam)

depth: float** grid: XYf** toCam: Pose3f returns: arr

arrlibct.cloudNormalFromSqrSumsf(sxx, syy, szz, sxy, sxz, syz, tmp33, eigenValues, eigenVectors, scaledCovariance)

sxx: float syy: float szz: float sxy: float sxz: float syz: float tmp33: float** eigenValues: XYZf * eigenVectors: M33f * scaledCovariance: M33f * returns: XYZf

arrlibct.cloudPropertiesFromSumsf(sx, sy, sz, sxx, syy, szz, sxy, sxz, syz, n, offset, tmp33, eigenValues, eigenVectors, covariance)

sx: double sy: double sz: double sxx: double syy: double szz: double sxy: double sxz: double syz: double n: uint offset: XYZf tmp33: float** eigenValues: XYZf * eigenVectors: M33f * covariance: M33f * returns: Lin3f

arrlibct.pointGridSurfaceStatistics(maskedPointGrid, winRows, winCols, stepRows, stepCols, minValidFraction, refVec, refAngleMin, refAngleMax)

maskedPointGrid: arr winRows: uint winCols: uint stepRows: uint stepCols: uint minValidFraction: float refVec: XYZf refAngleMin: float refAngleMax: float returns: arr

arrlibct.pointGridBoundingBoxMasking(pointGrid, validMask, box, boxPose)

pointGrid: XYZf** validMask: uint8** box: Box3f boxPose: Pose3f returns: void

arrlibct.growPlaneInSurfaceStatisticsGrid(facets, validMask, iCenter, jCenter, annuliOfGrowth, radiusMax, distanceThres, cosThres, rmsThres, connectivityImage, resultNormal, rms, slopeStd)

facets: Lin3f** validMask: uint8** iCenter: uint jCenter: uint annuliOfGrowth: XYi** radiusMax: float distanceThres: float cosThres: float rmsThres: float connectivityImage: uint8** resultNormal: Lin3f * rms: float * slopeStd: XYf * returns: uint

arrlibct.findConnectedFacets(facets, iCenter, jCenter, center, blobSpace, growthImage, connectedness, morph, pRMS, pNormal, pIndContour, pFacets)

facets: Lin3f** iCenter: uint jCenter: uint center: XYZf blobSpace: BlobSpace * growthImage: uint8** connectedness: uint morph: char * pRMS: float * pNormal: Lin3f * pIndContour: XYi* * pFacets: Lin3f** * returns: uint

arrlibct.computeFacetBlobContourProperties(camCenter, pointGrid, gridOrigin, gridStep, iCenter, jCenter, normal, indContour, filter, pRawContour, pFiltContour, pMinRectSize, pResultPose)

camCenter: XYZf pointGrid: XYZf** gridOrigin: XYu gridStep: XYu iCenter: uint jCenter: uint normal: Lin3f indContour: XYi* filter: char* pRawContour: XYf* * pFiltContour: XYf* * pMinRectSize: XYf * pResultPose: Pose3f * returns: float

arrlibct.findPlanesFromSurfaceStatistics(maskedPointGrid, surfaceStatistics, maxGrowthRadius, growthOffsetThreshold, growthAngleThreshold, growthRmsThreshold, connectedness, connectivityMorph, contourFilter, angleRange, rmsRange, validFacetCountRange, validFacetCountRangeInvert, minRectSizeRange, minRectSizeRangeInvert, minRectAreaRange, minRectAreaRangeInvert, contourAreaRange, contourAreaRangeInvert, axisRatioRange, axisRatioRangeInvert, contourCircularityRange, contourCircularityRangeInvert)

maskedPointGrid: arr surfaceStatistics: arr maxGrowthRadius: uint growthOffsetThreshold: float growthAngleThreshold: float growthRmsThreshold: float connectedness: uint connectivityMorph: char * contourFilter: char * angleRange: Box1f rmsRange: Box1f validFacetCountRange: Box1i validFacetCountRangeInvert: uint minRectSizeRange: Box2f minRectSizeRangeInvert: XYu minRectAreaRange: Box1f minRectAreaRangeInvert: uint contourAreaRange: Box1f contourAreaRangeInvert: uint axisRatioRange: Box1f axisRatioRangeInvert: uint contourCircularityRange: Box1f contourCircularityRangeInvert: uint returns: arr

arrlibct.rot2f(a)

a: float returns: M33f

arrlibct.rot2d(a)

a: double returns: M33d

arrlibct.vecRot2f(v)

v: XYf returns: M33f

arrlibct.vecRot2d(v)

v: XYd returns: M33d

arrlibct.info(key)

Print help on any name that contains ‘key’