GeoMaestro

-- Back --

Functions library



On-line documentation system



WARNING: please do not rely on information from this page, as I am rewriting it. The auto-documentation is the place to look for reliable functions descriptions.

Here are HTML pages directly generated from the KeyKit code:

Functions library


An alternate way to browse the library is to use the on-line documentation facilities:
funclist()
functype()
man()
seecode()

funclist(str) displays at the console a list of all KeyKit functions coded in the Keypath whose names contain the string str (a regular expression)

functopic(str) displays at the console a list of all KeyKit functions coded in the Keypath whose topics (keywords) contain the string str (a regular expression). Only some GeoMaestro functions have defined topics, though. To get a list of all topics, call functopic() with no argument.

man(fname) looks for documentation about the function called fname (a string) inside the code itself (there is a specific format for that, using the keywords #name, #usage, #desc and #see). It displays at the console all documentation it found, and if it found none it will at least display the first line of the function code, so that you know what are its arguments. It also gives the exact location of the code (file and line number)

seecode() opens the text editor on the *.k file in the Keypath corresponding to the last successful call of man(). This way you can quickly have the function code at hand.


Give it a try by typing the following commands at the console:
funclist("note")
man("makenote")
seecode()


If you're an Emacs user, you will find interest in the KeyKit major mode. Besides its editing utilities, it also includes a comprehensive auto-documentation browser; it is notably able to produce this kind of HTML pages.


Now I have to go through my sources and make use of the documentation format so that the on-line system becomes comprehensive... it will take some time :)



Here are briefly introduced the useful functions in GeoMaestro; "useful" means: "that you could find some interest into" or, less frequently, "that you need to use and understand otherwise you won't be able to do anything"

I'll present the functions the way they are displayed in the keylib.k file (which is automatically created by KeyKit when it encounters a .k file in its path)


You will very likely find that you hate some of theses function names (if not all of them !), because they're long and complicated and don't mean anything to you. Well, these are very good reasons to hate a function name.

So change it ! If you want to have your own name but keep GeoMaestro working with the horrible original one, you can create a wrapper like this in your initialisations.k file:

function NiceName(...) {return (HorribleName(...))}
That's it !



Functions sorted by usage:

Regions handling
Console utilities
Projectors
I/O
Initialisation functions
Basic utilities
Distortion functions
Activation functions
Events handling
Csound utilities
Misc



Functions sorted by names:

- Abs - ACpatchmap - ActiveCanal - ActiveRegion - ActiveTest - ActiveTout - AddLignes - AjouteAuScore - Aligne - ArCopy - Arrondi - AversB - BasicPan - BasicPitch - BigVAR - Bprint - Brown - Butterfly - Cerc - CerP - CercleRythm - CExport - choice_of_distortions - choice_of_generators - ChoixScene - CImport - clicks - Compteur - Convo - Cosi - CreateNewEvent - CreScen - CSeq - DansChoix - DesactiveCanal - DesactiveRegion - DesactiveTest - DesactiveTout - DessineMaille - Dist - DopplerLateral - DumpChantier - DureAuLoin - Echelle - Ecoute - EcouteC - EnglishBlahBlah - EnRond - EntrePistes - EnvironEgal - EvaLog - EvLabeled - EvPAC - EvPlusCol - ExLog - ExMIDI - ExScore - FichierN - FondAigu - FondBasses - ForgetBigVAR - ForgetVAR - FrenchBlahBlah - Geo - GetLSB - GetMIDIch - GetPatches - GetPhrase - Getpolar - GetpolarCP - GetPrograms - GetWavInfos - GMcolors - Go - GrosMIDI - HardCodeVAR - Helice - Hexa - Hexa16 - HLog - Id - InitACPat - InitConstantes - InitCScore - InitDur - InitEv - InitPAC - InitPan - InitParameters - InitPB - InitPit - InitScore - InitStatique - InitVolume - KeepScore - KKSR - KKSS - LargePan - Lissajous - ListVAR - LoadEv - LSeq - Maillage - MapChan - Maximum - MemeDur - MemeVol - MergeLignes - MetaRails - MHexa - MIDI - MIDIfile - Milieu - Minimum - Mod2Pi - MPlusP - MRect - NewLigne - NoBend - NoChanges - NoDoubleQuotes - NoEv - NoRemVARforthis - NoScore - Notepad - Onde - OperationScript - OptArgs - Padnote - parameters_infos - ParaPiste - Peri - PetitDoppler - Phamp - Piste - PlusCol - PlusP - PlusScene - PourAC - PourToutEv - PrintScore - proj_infos - RacineN - RandomAuLoin - RandomMix - RandomNotes - RCanal - RDisque - ReadDF - ReadPatches - ReadPiste - ReadScene - ReadScore - Region - RegionET - RegionOU - RegionPoint - RemoveEv - RemplaceInStr - RemVAR - RestoreChantier - ReVAR - Rose - RoseP - Rot - RRect - RTri - SameArrays - SaveScene - Sca - ScaleToTempo - ScaXY - SCgetpn - SCi - Scint - SCnump - SCp2Clicks - SCpn - SCpnAdd - Seg - SegA - SegB - SetEvPAC - Setpolar - SetpolarCP - Sgeo - ShowScore - Signe - Snarph - Spirale - Spiro - SupprimeIndex - SwapChan - TDiam - Thet - ToPiste - Trans - TreeInfos - Trochoid - UpdateNbCan - UpdateVAR - UseMIDI - UseMIDI_dur - UseMIDI_pan - UseMIDI_pit - UseMIDI_vol - Vague - Vexp1 - Vexp10 - VexpPARA - VolDansDisque - VolDEF - WriteDF - WriteEv - WritePiste - xyd - ZeroCOMPT - ZeroCompteur

Regions handling

Regions are the most powerful way available in GeoMaestro to precisely define parts of the event scene. They can be used to affect a specific behavior to some events, to restrict the operation of a projector (see Brown() for an example), to create sophisticated distortion functions, or in any other case where it is necessary to draw clear boundaries.

Basically, a region is simply a set of tests on Xx_, Yy_, Cc_ where (Xx_, Yy_) could be an event's coordinates and Cc_ its channel value. The tests are strings, arranged in a list (a 1-D array) and logically articulated by OR operators: that is, if at least one test in the list returns True, the (Xx_,Yy_,Cc_) triplet belongs to the region defined by the list.

As an example, here is a region:
[0 = 2,							# number of tests in the region
1 = "(D_ = sqrt(Xx_*Xx_+Yy_*Yy_)) >= 1 && D_<=2 && Yy_>0",	# first test: upper half of a ring
2 = "Xx_<0 && Yy_<0 && D_<=1"]				# second test: quarter of a disk 
and here is the area it represents:



In this example, the Cc_ parameter is not used.

You can see that we use the temporary variable D_: note that all temporary variables must be global, and also that it's safer to add a "_" to their name, so that a name conflict with an already existing user or KeyKit variable is improbable (for GeoMaestro variables, check a list of the reserved ones in the lib/initialisations.k file)

All images in this sections are produced by the GUI with a RegDensity parameter of 0.06, in mode RegFill = 3

Relative mode (for projections only):

While a region is by default a static area, its location can also be set relatively to the support when projecting. Let's say that RD is a disk region:
RD = RDisque(Or, 2)
...its center is the origin and its radius is 2.
When used as an optional region argument in a projector call, only the events located into this disk will be projected on the projector support.

Now if we set this region in relative mode, by typing:
RD["rel"] = 1
... its meaning as an optional argument in a projector call changes: this time, only the events located into the disk of radius 2 centered on their own projection on the support will be actually projected (the projected events will be the ones less than 2 units away from the support). The region follows the listening point on the support, so to say.

To set the region back to its absolute mode, type
RD["rel"] = 0




#library regions.k Region
Region(x, y, ch, reg)
x, y: floats
ch: integer (1 to NbCan)
reg: region
Returns 1 if the triplet (x,y,ch) belongs to reg, else returns 0

...this is the basic function for using regions in GeoMaestro

RegionPoint(pt, region)
pt: point
reg: region
This is a simpler version of Region(). It checks weither point pt belongs to reg (so here reg should be a pure geometrical region: with no test on the channel value)


#library regions.k RCanal

#library regions.k RDisque
#library regions.k RRect
#library regions.k RTri
RCanal(ch, ...)		# region is the whole ch channel  
RDisque(c, r, ...)	# disk centered on c with radius r
RRect(a, b, ...)	# rectangle whose corners are a and b
RTri(a, b, c, ...)	# triangle whose summits are a,b and c
a, b, c: points
r: float
ch: integer (1 to NbCan)

these functions returns a region ("area" in french), either geometrical (disk, triangle, rectangle) or based on the channel value; they can also be combined

the (...) optional arguments are (op, reg):
op: string ("" or "!")
reg: region
op is an operator: if it is set to "!", the complementary of the region is returned.
reg is the optional region we're adding to (OR operator)

Example:
Or = xy(0, 0)
Oi = xy(0, 1)
Oj = xy(1, 0)
Reg1 = RTri(Or, Oi, Oj, "", RDisque(Or, 1, "!"))
Reg2 = RRect(Oi, Oj, "", RDisque(Or, 1))
... Reg1 is the area defined by the union of the whole plane minus the disk centered in Or with radius 1 (kind of a hole !) and the triangle (Or, Oi, Oj) (which is in the hole!). So it looks like the blue part in this picture:



... while Reg2 looks like this:




The above examples Reg1 and Reg2 shows AND-combinations of regions obtained within the definition of a new sub-region. But you can also combinate with OR or AND operators already existing regions with the following functions:


#library regions.k RegionET
#library regions.k RegionOU
RegionET(reg1, reg2 , ...)
RegionOU(reg1, reg2)

reg1, reg2: regions
(...): op, reg (see above)
Intersection (ET=AND) and union (OU=OR) of two regions.

Let's see on a few examples:
this defines a ring:
ring = RegionET(RDisque(Or, 1, "!"), RDisque(Or, 2))
here we add the same ring to an existing "blob":
blob = RegionET(RDisque(Or, 1, "!"), RDisque(Or, 2), "", blob)
here is the region formed by two intersecting rings:
ring1 = RegionET(RDisque(Or, 1, "!"), RDisque(Or, 2))
ring2 = RegionET(RDisque(Oi, 1,  "!"), RDisque(Oi, 2))
inter = RegionET(ring1, ring2)
...this to add inter to blob:
blob = RegionOU(inter, blob)
I suggest you try these examples at the console; to display regions in the GUI, click on [display] and enter the region's name.



Console utilities


#library data.k EvPAC
#library console.k SetEvPAC
SetEvPAC(ch, msb, p)
ch: integer (1 to NbCan)
msb, p: integers (0 to 127)
write program change and MSB messages as the PAC value for channel ch

EvPAC(...)
...: integers (1 to NbCan)
returns the PAC values for channels (...) merged in a phrase


#library console.k PlusP
#library console.k MPlusP
PlusP(a, b)
a,b: points

adds two points/vectors and returns the resulting vector

MPlusP(f, a, b)
f: float
a,b: points

returns the vector f*a+b
b is optional, so this function can be used to scale a vector.


#library console.k Milieu
Milieu(a,b)
a,b: points

returns the middle point of segment (a,b)


#library console.k xyd

same as KeyKit xy() function, except that it doesn't transform float values to integer. Suitable to define points (two arguments) or segments (four arguments) from their coordinates.


#library console.k Cerc
Cerc(c, r)
c: point
r: float

returns circle of center c and radius r


#library console.k CerP
CerP(c, p)
c: point
p: float

returns circle of center c and perimeter p


#library console.k Seg
Seg(a,b)
a,b: points
or
Seg(x0,y0,x1,y1)
returns a segment defined by the corresponding arguments (the second syntax makes it identical to xyd() )


#library console.k SegA

#library console.k SegB
SegA(s)
SegB(s)
s: segment

returns one of the extremities of the segment s (as a point)


#library console.k Snarph
see here


#library console.k Sgeo
Sgeo(...)
Save geometrical objets in the BASE+"init.geo" file; this file is read by GeoMaestro when starting (see the Go() function in initialisations.k). All objects defined there (points, circles, regions, possibly arranged in arrays) are thus available in all GeoMaestro sessions. You can also directly edit this file with a text editor or a spreadsheet program.

For the exact syntax of the init.geo file, see Geo()

Sgeo() arguments must come in couples: first, a string containing the name of the object as it will appear in the .geo file; second, the variable to be saved under the previous name.

Example:
Ct  = xyd(1.5,-1)
Circle = Cerc(Ct, 2.5)
Sgeo("PCt", Ct, "Cir", Circle)
... the two first lines define a point Ct and a circle Circle, the last one save them so that they will be available at the next GeoMaestro session under the names PCt and Cir.

The following example added this to the init.geo :
Défini à la console:
#points
PCt 1.5 -1
#fin
#cercles
Cir 1.5 -1 2.5
#fin
see also RemVar() et GVARS as an alternative way to keep the values of variables between two KeyKit sessions


#library console.k HLog
#library console.k EvaLog
#library console.k ExLog

see here


#library console.k DumpChantier
#library console.k RestoreChantier
saves and restores arrays LOG, FT, FKK, FIF, SNARF and GVARS to/from a file.
default file name (if no argument is given): BASE+"variables.dat"

note: these arrays are also dumped with the GUI, so this is a parallel way to save and restore them


#library console.k RemVAR
#library console.k ReVAR
#library console.k UpdateVAR
#library console.k HardCodeVAR

see here and an example here


#library console.k Notepad
#library console.k Padnote

see here



Projectors


#library projection.k OptArgs

#library projection.k NewLigne

#library projection.k AddLignes

#library projection.k MergeLignes
see here


#library projection.k EcouteC
#library projection.k Spiro
#library projection.k Onde
#library projection.k Ecoute
#library projection.k Echelle
#library projection.k AversB
#library projection.k Helice
#library projection.k Brown
#library projection.k EntrePistes
#library projection.k Vague
#library projection.k PerspectiveAB
#library projection.k CercleRythm
#library lib_proj.k Scint
#library lib_proj.k LSeq
#library lib_proj.k CSeq
#library lib_proj.k MetaRails
#library lib_proj.k TDiam
see here





I/O


#library interfaces.k Geo
Geo(name, dir)
name, dir: strings

Reads the .geo file whose name is dir+name+".geo"

When starting, GeoMaestro calls
Geo("init", BASE)
... which means it reads the BASE+"init.geo" file (see Sgeo())


Syntax of a .geo file:

declarations of objects must happen between specific tags; outside tags, you can write anything you want; between tags, comments must be preceded by #. Versions of GeoMaestro earlier than 1.003 don't accept tabulation: use spaces to separate fields.

Points are defined between the following tags:
#points
#fin
Three definition modes are available: rectangular, polar (start with "p") and relative (start with ">").
Example:
#points
Or 0 0 		# Or = ["x"=0, "y"= 0]
p Oj 1 0.5*Pi	# Oj = Setpolar(1, 0.5*Pi) 
Oi 1 0		# Oi = ["x"=1, "y"= 0]
> II 0 1	# II = PlusP(Oi, ["x"=0, "y"=1])
> II2 0 1	# II2 = PlusP(II, ["x"=0, "y"=1])
#fin
Circles are defined between the tags:
#cercles
#fin
Two modes here: the circle center can be referenced by its name, or defined by its coordinates.
Example:
#cercles
C1 Or 1			# Or must have been defined before !
C2 0 0 2		# C2 = Cerc(["x"= 0, "y"=0], 2)
#fin
Regions are defined between the tags:
#regions
#fin
Three types of region can be directly defined: triangle ("t"), disk ("d") and rectangle ("r").
Regions can also be combined with the logical operators AND ("ET") and OR ("OU").
Points used in declarations must be refered to using their names.
Example:
#regions

t Joe AA BB Ch2         # this defines a triangle called Joe
			# ..AA, BB and Ch2 are points (and must be defined before !)

d Jack Or 2             # Jack is a disk of center Or and radius 2

r John AA BB            # John is a rectangle whose diagonal is (AA, BB)

t T1 Ch Chh BB          # T1 is the intersection of  T1, T2 and T3
ET t T2 Ch Ch2 AA	# (all are triangles)
ET t T3 AA BB Ch

d D2 Chh 1              # D2 is the union of D2 and D1
OU d D1 Ch 1		# (both of them are disks)

Jack                    # Jack becomes the union of previous Jack and D1
OU d D1 Ch 1
 
t- T1 Ch Chh BB         #  t-, d- and  r- are used for complementary regions
ET t- T2 Ch Ch2 AA
ET t T3 AA BB Ch

Mecs : Joe              # Mecs is the union of Joe, John and Jack
OU John
OU Jack

#fin

#library interfaces.k MIDI
#library interfaces.k ExMIDI
#library interfaces.k GrosMIDI
#library interfaces.k MIDIfile
MIDIfile(filename)
reads the MIDI file "filename" (and open a browser if given no argument), then convert it to the current tempo, so that it can be easily imported in a GeoMaestro scene. See here for a discussion on tempo matters, and tutorial 4 for an example of use.




#library interfaces.k RacineN
#library interfaces.k FichierN


#library interfaces.k KKSR
#library interfaces.k KKSS
#library interfaces.k OperationScript
#library interfaces.k GetMIDIch
#library interfaces.k Aligne
#library interfaces.k EnRond


Initialisation functions


#library data.k UpdateNbCan
UpdateNbCan(n)

n: integer (n >= 16)
Changes the number of GeoMaestro channels. It will change the format of the Ev, Volume, Pit, Dur, Pan, Time, Mer and CScore arrays. If the number of channels is reduced, the settings and events associated to the extra channels will be deleted.



#library initialisations.k Go
#library initialisations.k InitStatique
#library initialisations.k InitConstantes
#library initialisations.k NoDoubleQuotes
NoDoubleQuotes(str)

str: string
When called with no argument, this function lists at the console the aliases used to avoid double quotes in string indexes for array (see here). You can add your own aliases by updating the StringAlias array in intialisations.k

When call with argument str (a string), the corresponding replacement are done and a string without double quotes is returned. However, if it happens that a double quote is still present, an empty string is returned along with an error message at the console.

The main use of this function is to prevent strings containing double quotes to be dumped in one of the many tool's arrays, because this would make restoring the tool impossible.


#library initialisations.k InitVolume
#library initialisations.k InitPan
#library initialisations.k InitPit
#library initialisations.k InitPB
#library initialisations.k InitDur
#library initialisations.k InitEv
#library initialisations.k InitCScore
#library acpatches.k PourAC
#library acpatches.k RandomMix
#library acpatches.k ReadPatches
#library acpatches.k ACpatchmap
#library acpatches.k InitACPat


Basic utilities


#library librairie.k ArCopy
same as KeyKit arraycopy() (I didn't know it already existed when I wrote it !)

you should always use ArCopy() or arraycopy() when setting an array value from another array, because arrays are pointers in KeyKit: if you simply say:
array1 = array2
...then array1 and array2 will refer to the same value: any change in array1 applies to array2 (and more trouble is to come if array1 is a global variable while array2 is local... or the opposite).
on the other hand, if you say:
array1 = ArCopy(array2)
...array1 and array2 are two distincts arrays


#library librairie.k SupprimeIndex
if arr is an array whose first-level integer indexes range from 0 or 1 to n without any missing number, then
SupprimeIndex(p, arr)
returns arr with item number p deleted and the following indexes recalculated so that the last one is n-1 (other non-integer indexes are unchanged)

example:
Ar = 	[1 = "a",
	2 = "b",
	3 = "c",
	4 = "d",
	"bof" = "et oui"]

Br = SupprimeIndex(3, Ar)
returns this value for Br:
 	[1 = "a",
	2 = "b",
	3 = "d",
	"bof" = "et oui"]

#library librairie.k RemplaceInStr
RemplaceInStr(string, s1, s2)
replaces every occurence of substring s1 in string with substring s2 and returns the resulting string


#library librairie.k Setpolar

#library librairie.k Getpolar
Setpolar(a)
Setpolar(r,theta)
Getpolar(a)
Getpolar(x, y)
a: point
r, theta, x, y: float

used to transform rectangular coordinates ["x"=.., "y"=..] to polar coordinates ["r"=.., "theta"=..]

IMPORTANT: the polar coordinates returned by Getpolar are not a valid point format for any other function than Setpolar()


#library librairie.k SetpolarCP

#library librairie.k GetpolarCP
SetpolarCP(a)
SetpolarCP(r,theta)
GetpolarCP(a)
GetpolarCP(x, y)
a: point
r, theta, x, y: float

Same as Setpolar and Getpolar, but here the polar center is the point CentrePolaire, which is the origin of the polar grid and can take any value you want (Setpolar and Getpolar always refer to the origin point x=0,y=0)

IMPORTANT: the polar coordinates returned by GetpolarCP are not a valid point format for any other function than SetpolarCP()


#library librairie.k Mod2Pi
Mod2Pi(angle)
returns angle as a number from 0 to 2*Pi (not included)


#library librairie.k Hexa

#library librairie.k Hexa16
Hexa(n) 
returns hexadecimal value for n (0 to 255) as a string

Hexa16(n) 
returns hexadecimal value for n (0 to 15) as a string


#library librairie.k Arrondi
Arrondi(x)
x: float

returns the closest integer to x


#library librairie.k Signe
Signe(x)
x: float

returns -1 if x <= 0 and 1 if x > 0



#library librairie.k Abs
Abs(x)
x: float

returns Signe(x)*x


#library librairie.k EnvironEgal
EnvironEgal(x,y)
returns 1 if
abs(x-y) < 0.001
else returns 0


#library librairie.k Id
Id(arg,...)
simply returns arg !


#library librairie.k Minimum

#library librairie.k Maximum
Minimum(x,y)
returns x if x<y
else returns y

Maximun(x,y)
.. does the opposite


#library librairie.k Dist
Dist(a,b)
returns the distance (float) between points a and b


#library librairie.k Thet
Thet(a,b)
returns the angle between segment (a,b) and horizontal axe


#library librairie.k Peri
Peri(c)
c: circle

returns the perimeter of circle c




Distortion functions


#library lib_dist.k choice_of_distortions
#library lib_dist.k parameters_infos
#library lib_dist.k InitParameters
#library lib_dist.k NoChanges
#library lib_dist.k BasicPan
#library lib_dist.k LargePan
#library lib_dist.k Vexp1
#library lib_dist.k Vexp10
#library lib_dist.k VexpPARA
#library lib_dist.k MemeVol
#library lib_dist.k VolDEF
#library lib_dist.k D2
#library lib_dist.k VolDansDisque
#library lib_dist.k BasicPitch
#library lib_dist.k DopplerLateral
#library lib_dist.k FondBasses
#library lib_dist.k FondAigu
#library lib_dist.k MemeDur
#library lib_dist.k DureAuLoin
#library lib_dist.k RandomAuLoin
#library lib_dist.k NoBend
#library lib_dist.k PetitDoppler
#library lib_dist.k PB64
#library lib_dist.k PB8K


Activation functions


#library librairie.k ActiveCanal
#library librairie.k DesactiveCanal
#library librairie.k ActiveTout
#library librairie.k DesactiveTout
#library librairie.k ActiveRegion
#library librairie.k DesactiveRegion
#library librairie.k ActiveTest
#library librairie.k DesactiveTest


Events handling


#library data.k CExport
#library data.k CImport
#library data.k Convo
#library data.k Rot
#library data.k Trans
#library data.k Sca
#library data.k ScaXY
#library data.k CreScen
#library data.k PlusCol
#library data.k EvPlusCol
#library data.k SaveScene
#library data.k ReadScene
#library data.k ChoixScene
#library data.k Init16
#library data.k InitPAC
#library data.k PlusScene
#library data.k EvPlot
#library data.k WriteDF
#library data.k ReadDF
#library data.k WriteEv
#library data.k LoadEv
#library data.k GetPhrase
#library data.k NoEv
#library data.k Maillage
#library data.k DessineMaille
#library data.k MHexa
#library data.k MRect
#library data.k Idem
#library data.k DansChoix
#library data.k RandomNotes
#library data.k Piste
#library data.k WritePiste
#library data.k ReadPiste
#library lib_gen.k CreateNewEvent
CreateNewEvent(x, y, ch, nodur) 

x, y: float
ch: integer (1 to NbCan)
nodur: phrase
The name says all...

#library lib_gen.k PourToutEv
PourToutEv(func,...) 

func: function
Calls func(ev, ...) for each active event ev
It is very important that func() returns an event value, because this will be the new value for ev; also, func() should not delete any event nor move an event from a channel to another; it can only change the event.

Example:
function DispInfos(ev)
{
	print(ev["x"], ev["y"], ev["nodur"])
	return(ev)
}

PourToutEv(DispInfos)
... will display x,y,and nodur values for each event in the Ev scene.

#library lib_gen.k RemoveEv
RemoveEv(ch,n)

ch, n: integers (ch from 1 to NbCan)
Removes (deletes !) event n in channel ch, and updates all index numbers for channel ch

#library lib_gen.k EvLabeled
EvLabeled(label)

label: string
Returns the event labelled label, with the two extra fields "ch" and "n" allowing you to find back the event in the Ev array.

Example: if we have
Ev[2][25] = ["x"=1, "y"=2, "nodur"='a', "label"="Charlotte"]
then EvLabeled("Charlotte") returns the following array:
 ["x"=1, "y"=2, "nodur"='a', "label"="Charlotte", "ch"=2, "n"=25]
... usually only the "ch" and "n" fields are realy useful, since they make it possible to keep track of a specific event in a changing Ev scene (remember that the index number of an event is subject to changes, if others events are deleted or moved to another channel)

#library lib_gen.k choice_of_generators
#library lib_gen.k Compteur
#library lib_gen.k ZeroCompteur
#library lib_gen.k ZeroCOMPT


CSound utilities


#library csound.k PrintScore
#library csound.k ReadScore
#library csound.k ExScore
#library csound.k InitScore
#library csound.k AjouteAuScore
#library csound.k SCp2Clicks
#library csound.k SCpn
#library csound.k SCgetpn
#library csound.k SCpnAdd
#library lib_csound.k NoScore
#library lib_csound.k UseMIDI_dur
#library lib_csound.k UseMIDI_vol
#library lib_csound.k UseMIDI_pit
#library lib_csound.k UseMIDI_pan
#library lib_csound.k UseMIDI
#library lib_csound.k CStest
#library lib_csound.k SCExample


Misc


#library franglish.k FrenchBlahBlah
#library franglish.k EnglishBlahBlah
#library wclavier.k wclavier





-- Back --