Jump to content

torstenanders

Members
  • Content Count

    371
  • Joined

  • Last visited

1 Follower

About torstenanders

  • Rank
    Senior Member

Contact Methods

Profile Information

  • Gender
    Male

Recent Profile Visitors

2,425 profile views
  1. > Do you consider the inconsistency of the integer-to-pitch results a bug? I cannot speak for Janusz, but for me the format of the result makes sense. If there are individual values in the integer pitch list it is assume that the overall result is considered flat and hence sublists are chords. If everything is nested, then sublists are considered bars and the nesting is preserved. Best, Torsten
  2. Thanks for the update Janusz. I am trying to port some code that uses length-divide2, but the interface changed as well, and I do not have access anymore to the old documentation of the original function. length-divide2 had three positional arguments, but length-subdivision has only two. The former first two arguments are now expressed as sublists of the new first argument, i.e., a matrix-transpose transformation of the former first and second argument? Thanks! Best, Torsten PS: I am all for refactoring of Opusmodus functions, but if you want people to develop code that depends on Opusmodus functions, then it would be helpful if those changes are even more carefully described ------------------------------------------- > Enable or disable the DO-VERBOSE macro. I tried doing that in a file in the folder Opusmodus/Extensions. I confirmed that this file is loaded (e.g., setting *snippet-length-line* in the same file works) and that setting *do-verbose* to NIL does what it is supposed to do, but somehow the value of *do-verbose* is overwritten to T again after that extension file is loaded. Is that expected? I checked that this variable is not changed anywhere in my code (it never occurs on my machine except that extension). Do you recommend setting this variable somewhere else in some automatically loaded file? Thanks! Best, Torsten
  3. > That is the main and most important point on the todo list i'm waiting for ! I would also welcome this greatly, but I also understand that it might be tricky to realise when implemented from scratch, as MusicXML is a large standard. This project could become much much smaller when using some library that already has some good MusicXML support. For example, one could use the pretty mature MusicXML import of music21 (http://web.mit.edu/music21/) and then use music21 + Python to generate OMN (e.g., an event list as output by Opusmodus' single-events). I did something similar once, that is rather easy to do and not such a big project. Python libraries can be called from Common Lisp using py4cl (https://github.com/bendudson/py4cl/). I tested py4cl in Opusmodus, it works. For example, all OMN generation could be done in a custom Python module, and py4cl is then used for just calling that. It seems the music21 licence would allow for that (https://github.com/cuthbertLab/music21/blob/master/music21/license.txt). Any Opusmodus user with a little bit of Python knowledge (which is rather easy for a Lisp programmer, see https://norvig.com/python-lisp.html) and some time could to that in principle Best, Torsten
  4. Perhaps – if others would also find such control useful – some checkbox could also be added to the preferences, e.g., under Appearance > Listener. Anyway, only if this is relevant for other users... Thanks again! Best, Torsten
  5. Is there perhaps any way to switch off all those trace prints created by very many Opusmodus functions. Here is an example: I want to get rid of printout(s) before the actual result. OM> (pitch-transpose 2 '(q c4)) pitch-transpose, transpose: 2 ambitus: PIANO section: NIL exclude: NIL (Q D4) These constant traces are problematic for me, because in all those prints I very easily miss printouts that are particularly important (e.g., warnings from some functions). I am aware of the Opusmodus function do-verbose. I would very much like to avoid adding do-verbose to my own functions. On the contrary, I am asking for a way to globally switch off what do-verbose does in other functions, e.g., by some global variable. That should be easy to implement (e.g., in the definition of do-verbose, if that global variable is set to NIL, no printing happens). Besides, if I really want some trace of function calls, this is actually already build-in into Common Lisp in a way that can be switched on and off selectively for any function with trace. BTW: The example shown at HyperSpec (http://clhs.lisp.se/Body/m_tracec.htm) does not quite work as expected in CCL, because CCL cleverly inlines all the recursive calls, but that can also be switched off (see https://trac.clozure.com/ccl/wiki/DebugWithOpenmcl). Besides, CCL offers also an extended version of trace (https://ccl.clozure.com/manual/chapter4.2.html). Further, I usually need traces during debugging, and Common Lisp IDEs usually provide even interactive backtraces (e.g., not only the arguments of functions, but also values of local variables within the lexical scope of functions can be seen, changed, and used in arbitrary test evaluations). I guess that such facilities have been purposefully disabled in Opusmodus, because such power can initially confuse new users. EDIT: basically, what I want to do is ensure that the internal function %do-verbose does not do anything if it is switched off, like so. (defparameter *do-verbose?* T "Enable or disable traces printed by do-verbose.") (defun %do-verbose (<args>) (when *do-verbose?* <put-orig-def-here>)) I cannot add this definition myself because I do not have the original code of this definition, and because the definition of this function is protected and cannot easily be overwritten by users. I should perhaps add that I appreciate that the do-verbose traces can be useful for getting the seed of some function call for "freezing" some result one might like. However, for me this usefulness still does not mean this feature should be switched on all the time. Thanks!
  6. >> While I can create a canon, counterpoint and a fugue myself with a bit of time, it would be much less time-consuming for me if I were able to use existing examples. Is there an existing library of OMN examples of these types of compositions? > I cannot offer ready-made examples, but a constraint-based library with various counterpoint (and also harmony) rules ready-made. Following up my own comments, some entry level introduction to the libraries Cluster Engine and Cluster rules is offered by a video I prepared for my students last autumn. https://www.youtube.com/watch?v=xPXIRmH9rZc&list=PLmbpscTxjn_DrdDXD5v7z0GzQRNKM5VyQ&index=9 This video uses PWGL instead of Openmusic, but you only need to mentally replace PWGL boxes with Lisp functions of the same name to get pretty much the equivalent Opusmusic code. Also, this tutorial only scratches the surface of what can be done with these libraries, but I hope it can give an initial idea how things are approached in these libraries and for going beyond that a relatively easy approach is simply to study the pre-programmed rules in the Cluster Rules library and trying to combine rules for your own purposes. Once you miss a specific rule you would like to have, the library Cluster Engine provides the tools for defining your own rules on a high level of abstraction (specifically, it provides many abstractions that help to easily apply your rule to a specific score context, like the pitches of simultaneous notes of certain parts). This video is the last of a series of introduction-level videos on algorithmic composition with PWGL... https://www.youtube.com/playlist?list=PLmbpscTxjn_DrdDXD5v7z0GzQRNKM5VyQ
  7. Brilliant. Now my most-used Opusmodus shortcuts also work in Emacs. That helps my workflow a lot! Thanks!! Could you perhaps also share some example of one of the Opusmodus keyboard shortcut definitions (e.g., something like OMN Audition). Then I could hopefully use that to define a shortcut for starting playback with my custom score data structure in Opusmodus. It does not matter if that example definition would be complex and you do not need to provide any user-friendly abstraction. Just some example code would help a lot. Thanks again! Best, Torsten
  8. Thanks, but what is the Lisp function, not the shortcut, for stopping playback. I can start playback of the last score with (audition-last-score), how can I stop it Thanks! Best, Torsten
  9. What is the Lisp function for stopping playback (bound to the shortcut cmd-esc)? ... I could never add a custom keyboard shortcut to the Opusmodus text editor Hemlock (and I tried), but I just managed adding keyboard shortcuts and a menu for playing Opusmodus snippets and my polyphonic score format to Emacs (thanks to the fact that scores now can be displayed in a separate window). Only need some key for stopping playback as well. (The main thing I will then miss when using Emacs as the Opusmodus IDE is the close integration of the document, but well, you cannot have everything On the plus side, I have a more stable editor and in particular a very good debugger.) Thanks! Torsten
  10. >> Common Music does not "see" CLM and the interface to it is broken, because CLM is now seemingly defined in another package. > It looks like you don't know how to use CLM in Opusmodus I understand that CLM can be used directly from Opusmodus, but there also exists an interface between Common Music and CLM (I used that already in the 90s...), which is broken in the CLM port to Opusmodus when loading Common Music into it was well. Anyway, I doubt anyone with miss that Best, Torsten
  11. Do you mean as an option for the function length-divide? That would be great, but my preferred solution would be to have some extra function complementing gen-swallow for added notes -- which then could be called within functions like length-divide -- because that would be a generic solution for all sorts of functions that somehow add notes. The slightly tricky bit would perhaps be for the function to notice which are the new notes, so it should likely get as an input both the original material and the material with the added notes to find out... I would be happy to help sketching such a function... One approach might also be if functions adding notes would somehow mark such notes with some custom articulation only used for that purpose, but that would only work for full OMN results, not single parameters (e.g., length-divide supports single length values). An alternative idea would be for functions adding notes to simply specify the positions in the resulting list that they added (with some special notation for nested lists). Anyway, if it would be much more simply to refactor only length-divide and friends, that would be welcome too...
  12. The function LENGTH-DIVIDE and friends are a useful device for introducing some rhythmic variation to some material. However, when the processed sequence is a full OMN expression (see example below), then the added notes cause all other parameters to shift forward (additional parameters are added at the end by looping). For introducing only a slight variation to some existing material (e.g., motif) these functions are therefore not so useful, because this shift of all parameters to basically "fill" the new added notes with pitches etc. greatly change the varied material for a listener. (length-divide 1 2 '(q f3 leg+m1 q ab3 leg e c4 leg bb3 leg ab3 leg g3)) Basically, this is the opposite situation of the situation addressed by swallowing. Swallowing (e.g., with GEN-SWALLOW and the swallow argument of many other functions) avoids the shift of parameters like pitch etc. that would result from removing notes and turning them into rests. For addressing the situation above properly we would need something like the opposite of swallowing, some way to fill in parameters like pitch etc. for new notes to avoid shifting existing notes. I hope my explanation makes sense and you can see why something like the opposite of swallowing would be useful for functions that add notes to some input material. Now, the tricky question is of course, what parameters (pitch etc.) should be added in such cases. Musically useful and common in the classical literature would be, e.g., repeating the parameters (pitch etc.) of the predecessor note (though that might be a bit too simplistic and annoying at times) or somehow interpolating some pitch gap between the previous and next note with a little scale or arpeggio and only repeating the other parameters like articulations (resulting in some variation that is likely most similar to the input material, so it would be good to have that as an option). If the pitch interval between the two original notes is too small to add some pitch in between for the new now (or as an option in general for variety), it would also be good to add some ornamentation (e.g., using PITCH-ORNAMENT), but for a close similarity between the original material and the variation it would be best as an option to apply such ornamentation only to the newly added notes, not all notes. Of course, other options could also be useful for variations that vary the input material a bit more strongly, e.g., some random pitch for the new notes within certain interval bounds. Does some function that kind of is the opposite of GEN-SWALLOW in that it adds parameters like pitches for subdivided rhythmic values (to avoid the shifting) sound like a good idea? The idea with the interpolation of gaps could be implemented by turning the original duration values and pitches into some envelope and then reading that envelope with the new rhythmic values. So, that is rather strait forward. However, that would not allow for some ornamentation, because such algorithm would not recognise which notes are new that should be ornamented. Any other idea perhaps? Thanks!
  13. Thanks for coming back. Here is a little demo example snippet. This example shows a very simple motif and its repetition. I would like to annotate some motif label (I will use such labels also for segmenting parts for further processing -- that works fine). (add-text-attributes ;; motif start signs '(m1 "m1") '(m2 "m2") '(m3 "m3") '(m4 "m4") '(m5 "m5") '(m6 "m6") '(m7 "m7") '(m8 "m8") '(m9 "m9") '(m10 "m10") ) '(q c4 m1+leg d4 q c4 m1+leg d4) By contrast, the attribute num1 behaves differently. '(q c4 num1+leg d4 q c4 num1+leg d4) I would like to be able to define custom text-attributes that behave like num1 and friends. Thanks again! (If I am the only one who wants such a feature this does not need to have high priority :)
×
×
  • Create New...