def load_flame(self, flame_origin, flame_target=None, lerp=0.0):
loaded_flame = self.flame
try:
if (lerp == 0.0 or flame_target is None):
loaded_flame = flame_origin
elif (lerp >= 1.0 or flame_origin is None):
loaded_flame = flame_target
else:
# interpolation:
flame_origin.time = 0
flame_target.time = 1
flames_lerp = [flame_origin, flame_target]
flames_str = "<flames>%s</flames>" % "".join(
map(flame_to_string, flames_lerp))
genomes, ngenomes = Genome.from_string(flames_str)
targetflame = Genome()
flam3_interpolate(genomes, ngenomes, lerp, 0,
byref(targetflame))
loaded_flame = Flame(targetflame.to_string())
except Exception as ex:
print('[!] error during interpolation at %s: %s' % (lerp, str(ex)))
traceback.print_exc()
return None
return loaded_flame
def flam4_render(flame, size, quality, **kwds):
"""Passes requests on to flam4. Works on windows only for now."""
from fr0stlib.pyflam3 import _flam4
flame = flame if type(flame) is Flame else Flame(flame)
flam4Flame = _flam4.loadFlam4(flame)
output_buffer = _flam4.renderFlam4(flam4Flame, size, quality, **kwds)
return output_buffer
def OnSelChanged(self, event):
item = event.GetItem()
event.Skip()
if self.tree._dragging:
# Don't reselect flames when a drop is happening.
return
if item and len(self.tree.GetIndexOfItem(item)) == 2:
# Item is a flame
self.tree.item = item
self.tree.parentselected = False
string = self.tree.GetFlameData(item)[-1]
self.parent.SetFlame(Flame(string=string))
else:
# Item is a flamefile
self.tree.parentselected = True
self.parent.Enable(ID.UNDO, False)
self.parent.Enable(ID.REDO, False)
def TempSave(self):
"""Updates the tree's undo list and saves a backup version from
which the session can be restored."""
# HACK: this prevents loads of useless tempsaves when running a script.
# the GUI can still be manipulated. This also prevents some weird
# segfaults.
# Update 25/01/2011: Looks like this isn't necessary anymore now
# that canvas is refactored.
##if self.scriptrunning:
## return
data = self.tree.itemdata
# Check if flame has changed. to_string is needed to detect identical
# flames saved in different apps. This comparison takes about 5ms.
string = self.flame.to_string()
if Flame(data[-1]).to_string() != string:
data.append(string)
self.tree.SetItemText(self.tree.item, data.name)
self.DumpChanges()
self.tree.RenderThumbnail()
self.SetFlame(self.flame, rezoom=False)
def MakeFlame(self):
flame = Flame()
flame.add_xform()
flame.gradient.random(**config["Gradient-Settings"])
return flame
def _handler(self, e):
data = self.tree.itemdata
self.SetFlame(Flame(string=getattr(data, name)()), rezoom=False)
self.tree.RenderThumbnail()
self.tree.SetItemText(self.tree.item, data.name)
self.DumpChanges()
def to_string(flame):
if isinstance(flame, basestring):
if needs_conversion(flame):
return Flame(flame).to_string()
return flame
return flame.to_string()
import logging
import time
from fr0stlib import Flame
from fr0stlib.render import save_image
from fr0st.scripts.mindmurmer.sound_controller import MindMurmurHeartbeatAudioController
from utils import get_scriptpath
from eegsources import *
# For running the script as stand alone and not through the fractal app
if 'flame' not in locals() and 'flame' not in globals():
print "generating random flame"
flame = Flame()
flame.add_xform()
if 'large_preview' not in locals() and 'preview' not in globals():
def DoNothing():
pass
large_preview = DoNothing
preview = DoNothing
class MMEngine:
def __init__(self, eeg_source, gui, audio_folder):
self.eeg_source = eeg_source
self.audio_controller = MindMurmurHeartbeatAudioController(
audio_folder)
self.frame_index = 0
def setUp(self):
self.flame = Flame(flame_str)
def open_flame(path):
if os.path.exists(path):
return [Flame(s) for s in load_flamestrings(path)]
else:
raise FileNotFoundError(path)
