TSE3::Util::PowerQuantise Class Reference

Staggeringly impressive Phrase quantisation. More...

#include <PowerQuantise.h>

Collaboration diagram for TSE3::Util::PowerQuantise:

[legend]List of all members.

Public Types
enum	Direction { nearest, backwards, forwards }
enum	Length { quantiseOffTime, quantiseLength }
Public Member Functions
	PowerQuantise ()
Pattern &	pattern ()
int	by () const
void	setBy (int by)
int	window () const
void	setWindow (int window)
bool	onlySelected () const
void	setOnlySelected (bool s)
bool	onlyNotes () const
void	setOnlyNotes (bool n)
bool	spreadCtrl () const
void	setSpreadCtrl (bool s)
Direction	direction () const
void	setDirection (Direction d)
Length	length () const
void	setLength (Length l)
int	lengthBy () const
void	setLengthBy (int by)
TSE3::Clock	humanise () const
void	setHumanise (TSE3::Clock h)
TSE3::Clock	lengthHumanise () const
void	setLengthHumanise (TSE3::Clock h)
void	go (TSE3::PhraseEdit *phraseEdit)

---

Detailed Description

Staggeringly impressive Phrase quantisation.

This utility class provides you with more quantising capabilities than you ever dreamt possible.

The class is used by specifying the set of parameters to run the PowerQuantise with, and then providing a (tidied) PhraseEdit object containing the source MidiData to quantise. Once the PowerQuantiser is run, the PhraseEdit will contain tidied, (powerfully) quantised MidiData.

Some of the facilities provided by PowerQuantise are:

• Quantise to user-supplied pattern (or 'groove')
• Shift events by percentage
• Windowing
• Only quantise selection
• Only quantise note events
• Spread continuous controllers intelligently between new note positions
• Quantise notes forwards, backwards, or to the nearest snap point
• Quantise note length or note off time
• Humanisation

To be completed

This class isn't a Notifer yet, but it will be. I imagine that the PowerQuantise::Pattern class will also be Serializable so that you can save a library of named patterns. Watch this space.

Author:

Pete Goodliffe

Version:

3.00

See also:

PhraseEdit

PowerQuantise::Pattern

---

Member Enumeration Documentation

enum TSE3::Util::PowerQuantise::Direction

Enumeration values: nearest  backwards  forwards

enum TSE3::Util::PowerQuantise::Length

Enumeration values: quantiseOffTime  quantiseLength

---

Constructor & Destructor Documentation

TSE3::Util::PowerQuantise::PowerQuantise (   )

Creates a PowerQuantise object with a sensible default set-up.

---

Member Function Documentation

Pattern& TSE3::Util::PowerQuantise::pattern (   )  [inline]

int TSE3::Util::PowerQuantise::by (   )  const [inline]

Returns the percentage by which events will be quantised towards a snap point. 100% will move the command exactly to the snap point. 50% will move it half way towards it. 110% will move the event just past the snap point. This is a way of preventing the quantised MidiData from sounding too mechanised. See also: setBy

void TSE3::Util::PowerQuantise::setBy (  int  by  )

Sets the percentage shift value. See also: by

int TSE3::Util::PowerQuantise::window (   )  const [inline]

This is a percentage value that controls which MIDI events get quantised. At 0% no events will be quantised. As the value increases, events near to (and then further away from) snaps points begin to get quantised. At 100% all MIDI events will be quantised. See also: setWindow

void TSE3::Util::PowerQuantise::setWindow (  int  window  )

Sets the window value. See also: setWindow

bool TSE3::Util::PowerQuantise::onlySelected (   )  const [inline]

If true, this parameter forces PowerQuantise to only alter selected events. (This uses the selected bit in a MidiCommand). If false, PowerQuantise alters all events (that pass other event filters). See also: setOnlySelected

void TSE3::Util::PowerQuantise::setOnlySelected (  bool  s  )

Sets the onlySelected value. See also: onlySelected

bool TSE3::Util::PowerQuantise::onlyNotes (   )  const [inline]

If true, this parameter forces PowerQuantise to only alter note MIDI events. If false, PowerQuantise alters all events (that pass other event filters). See also: setOnlyNotes

void TSE3::Util::PowerQuantise::setOnlyNotes (  bool  n  )

Sets the onlyNotes value. See also: onlyNotes

bool TSE3::Util::PowerQuantise::spreadCtrl (   )  const [inline]

This is a very powerful feature that prevents continuous MIDI controller events (pitch bend, pan, reverb, etc) being pulled toward snap points as most sequencers will do. This tends to remove the continuous nature of the pattern of these events. Enabling this feature spreads the controllers between their surrounding note events after the quantisation. This spread will follow the same pattern that they originally were positoned in. This means that pitch bend slides, for example, will sound pretty much as they did prior to the quantise. See also: setSpreadCtrl

void TSE3::Util::PowerQuantise::setSpreadCtrl (  bool  s  )

Sets the spreadCtrl value. See also: spreadCtrl

Direction TSE3::Util::PowerQuantise::direction (   )  const [inline]

This returns which snap point a MIDI event moves towards. This will normally be the nearest available snap point, but you can shoose to snap all events forwards or backwards. See also: setDirection

void TSE3::Util::PowerQuantise::setDirection (  Direction  d  )

Sets the direction value. See also: direction

Length TSE3::Util::PowerQuantise::length (   )  const [inline]

This returns what PowerQuantise does with MidiCommand_NoteOffs. You can choose to either snap the length of a MidiCommand_NoteOn to MidiCommand_NoteOff to the pattern, or quantise the actual time of the MidiCommand_NoteOff. You can also specify separate percentage shift and humanise values for note lengths. See also: setDirection

void TSE3::Util::PowerQuantise::setLength (  Length  l  )

Sets the length value. See also: length

int TSE3::Util::PowerQuantise::lengthBy (   )  const [inline]

Returns the percentage by which note lengths are moved towards their quantised value. See also: by setLengthBy

void TSE3::Util::PowerQuantise::setLengthBy (  int  by  )

Sets the percentage shift value. See also: lengthBy

TSE3::Clock TSE3::Util::PowerQuantise::humanise (   )  const [inline]

After an event is quantised, you can choose to have it moved by a random value (up to the a specified number of pulses which is returned by this function). This is an alternative way of preventing the quantised MidiData sounding 'mechanised' by introducing slight human-like errors. A value of zero will disable the humanise facility. See also: setHumanise lengthHumanzie

void TSE3::Util::PowerQuantise::setHumanise (  TSE3::Clock  h  )

Sets the humanise value. See also: humanise

TSE3::Clock TSE3::Util::PowerQuantise::lengthHumanise (   )  const [inline]

This is a separate value of humanise which applies to MidiCommand_NoteOff MIDI events. See also: humanise setLengthHumanise

void TSE3::Util::PowerQuantise::setLengthHumanise (  TSE3::Clock  h  )

Sets the length humanise value. See also: lengthHumanise

void TSE3::Util::PowerQuantise::go (  TSE3::PhraseEdit *  phraseEdit  )

Do the PowerQuantise on the given PhraseEdit.

---

The documentation for this class was generated from the following file:

• /home/pete/Work/TSE3.svn/tse3/src/tse3/util/PowerQuantise.h

---