def setUp(self):
self.compiler = fc.Compiler()
self.compiler.add_func_path("../formulas")
self.compiler.add_func_path("../fract4d")
self.f = gtkfractal.T(self.compiler)
self.settings = painter.PainterDialog(None, self.f)
def setUpClass(cls):
cls.tmpdir = tempfile.TemporaryDirectory(prefix="fract4d_")
cls.userConfig = fractconfig.T("")
cls.userConfig.set("general", "cache_dir",
os.path.join(cls.tmpdir.name, "gnofract4d-cache"))
cls.userConfig["formula_path"].clear()
cls.userConfig["map_path"].clear()
cls.g_comp = fc.Compiler(cls.userConfig)
cls.g_comp.add_func_path("fract4d")
cls.g_comp.add_func_path("formulas")
def setUp(self):
self.tmpdir = tempfile.TemporaryDirectory(prefix="fract4d_")
self.userConfig = fractconfig.T("")
self.userConfig.set("general", "cache_dir",
os.path.join(self.tmpdir.name, "gnofract4d-cache"))
self.userConfig["formula_path"].clear()
self.userConfig["map_path"].clear()
self.g_comp = fc.Compiler(self.userConfig)
self.g_comp.add_func_path("../fract4d")
self.g_comp.add_func_path("../formulas")
def testPrefs(self):
compiler = fc.Compiler(Test.userConfig)
prefs = fractconfig.T("testprefs")
prefs.set("compiler", "name", "x")
prefs.set("compiler", "options", "foo")
prefs.set_list("formula_path", ["fish"])
prefs.set_list("map_path", ["wibble"])
compiler.update_from_prefs(prefs)
self.assertEqual("x", compiler.compiler_name)
self.assertEqual("foo", compiler.flags)
self.assertEqual(["fish"], compiler.path_lists[0])
self.assertEqual(["wibble"], compiler.path_lists[3])
def testFileTimeChecking(self):
'Check we notice when a file changes'
f2 = fc.Compiler(Test.userConfig)
formulas = '''
test_circle {
loop:
z = pixel
bailout:
|z| < @bailout
default:
float param bailout
default = 4.0
endparam
}
test_square {
loop:
z = pixel
bailout: abs(real(z)) > 2.0 || abs(imag(z)) > 2.0
}
'''
fftest_file = os.path.join(Test.tmpdir.name, "fttest.frm")
with open(fftest_file, "w") as f:
f.write(formulas)
f2.load_formula_file(fftest_file)
frm = f2.get_formula(fftest_file, "test_circle")
self.assertEqual(frm.symbols.default_params(), [0, 4.0])
formulas = formulas.replace('4.0', '6.0')
time.sleep(1.0) # ensure filesystem will have a different time
with open(fftest_file, "w") as f:
f.write(formulas)
frm2 = f2.get_formula(fftest_file, "test_circle")
self.assertEqual(frm2.symbols.default_params(), [0, 6.0])
def testInstance(self):
compiler = fc.Compiler(Test.userConfig)
self.assertNotEqual(None, compiler)
self.assertEqual(compiler.flags,
fractconfig.T("").get("compiler", "options"))
def generate_fct(self):
self.values = []
self.durations = []
version = self.find_version()
if version == '-1':
self.show_error(
"Could not find gnofract4d version. Can not continue")
yield False
return
#-------------loads gnofract4d libs----------------------------
try:
self.fractal = fractal
self.compiler = fc.Compiler()
self.compiler.add_func_path("formulas")
self.compiler.add_func_path("../formulas")
self.compiler.add_func_path(
fractconfig.instance.get_data_path("formulas"))
except:
self.show_error("Gnofract4d libs could not be found")
yield False
return
#--------------------------------------------------------------
#find values from base keyframe first
try:
ret = self.find_values(self.dir_bean.get_base_keyframe())
if len(ret) == 11:
self.values.append(ret)
else:
self.show_error("Unknown error during reading base keyframe")
yield False
return
except:
self.show_error("Unknown error during reading base keyframe")
yield False
return
try:
#find values and duration from all keyframes
for i in range(self.dir_bean.keyframes_count()):
ret = self.find_values(self.dir_bean.get_keyframe_filename(i))
if len(ret) == 11:
self.values.append(ret)
elif len(ret) > 1:
self.show_error("Error finding %s values in file: %s" %
(ret[0], ret[1]))
yield False
return
else:
self.show_error("Error reading .fct file")
yield False
return
self.durations.append(self.dir_bean.get_keyframe_duration(i))
#interpolate and write .fct files
for i in range(self.dir_bean.keyframes_count()):
if self.running == False:
yield False
break
self.write_fct_file(i)
percent = float(i + 1) / float(self.dir_bean.keyframes_count())
if self.running == False:
break
self.pbar.set_fraction(percent)
self.pbar.set_text(str(percent * 100) + "%")
yield True
except:
self.show_error("Unknown error during generation of .fct files")
yield False
return
if self.running == False:
yield False
return
self.running = False
self.dialog.destroy()
yield False
import math
import os
import gettext
import sys
sys.path.insert(1, "..")
from fract4d import fc, fractal
import gtkfractal
import gtk
os.environ.setdefault('LANG', 'en')
gettext.install('gnofract4d')
# centralized to speed up tests
g_comp = fc.Compiler()
g_comp.add_func_path("../fract4d")
g_comp.add_func_path("../formulas")
class FakeEvent:
def __init__(self,**kwds):
self.__dict__.update(kwds)
class CallCounter:
def __init__(self):
self.count = 0
def cb(self,*args):
self.count += 1
class Recurser:
def __init__(self):
def __init__(self, userConfig, extra_paths=[]):
self.quit_when_done = False
self.save_filename = None
self.compress_saves = True
self.f = None
self.use_preview = True
self.normal_display_size = None
self.normal_window_size = None
self.userConfig = userConfig
self.userPrefs = preferences.Preferences(userConfig)
self.four_d_sensitives = []
# window widget
self.window = Gtk.Window()
self.window.set_default_size(
self.userPrefs.getint("main_window", "width"),
self.userPrefs.getint("main_window", "height"))
self.window.connect('delete-event', self.quit)
self.window.connect('window-state-event', self.on_window_state_event)
self.window.set_name('main_window')
theme_provider = Gtk.CssProvider()
css_file = "gnofract4d.css"
this_path = os.path.dirname(sys.modules[__name__].__file__)
css_filepath = os.path.join(this_path, "..", css_file)
if not os.path.exists(css_filepath):
css_filepath = fractconfig.T.get_data_path(css_file)
theme_provider.load_from_path(css_filepath)
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), theme_provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
# custom icon images for toolbar buttons
Gtk.IconTheme.prepend_search_path(
Gtk.IconTheme.get_default(),
os.path.dirname(
fractconfig.T.find_resource('pixmaps/explorer_mode.png', '..',
'')))
# keyboard handling
self.keymap = {
Gdk.KEY_Left: self.on_key_left,
Gdk.KEY_Right: self.on_key_right,
Gdk.KEY_Up: self.on_key_up,
Gdk.KEY_Down: self.on_key_down,
Gdk.KEY_Escape: self.on_key_escape
}
self.window.connect('key-press-event', self.on_key_press)
self.window.connect('key-release-event', self.on_key_release)
# create fractal compiler and load standard formula and
# coloring algorithm files
self.compiler = fc.Compiler(userConfig)
for path in extra_paths:
self.compiler.add_func_path(path)
self.vbox = Gtk.VBox()
self.window.add(self.vbox)
self.f = gtkfractal.T(self.compiler, self)
self.f.freeze() # create frozen - main prog will thaw us
self.create_subfracts(self.f)
self.set_filename(None)
try:
# try to make default image more interesting
self.f.set_cmap(
fractconfig.T.find_resource("basic.map", "maps", "maps"))
except Exception as ex:
#print ex
pass
self.model = model.Model(self.f)
self.userPrefs.connect('image-preferences-changed',
self.on_prefs_changed)
self.create_ui()
self.create_toolbar()
self.panes = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL)
self.vbox.add(self.panes)
self.create_status_bar()
self.create_fractal(self.f)
self.panes.pack1(self.swindow, resize=True, shrink=True)
# show everything apart from the settings pane
self.window.show_all()
self.settingsPane = settings.SettingsPane(self, self.f)
self.panes.pack2(self.settingsPane, resize=False, shrink=False)
# create these properly later to avoid 'end from FAM server connection' messages
self.saveas_fs = None
self.saveimage_fs = None
self.hires_image_fs = None
self.open_fs = None
self.renderQueue = renderqueue.T(self.userPrefs)
self.update_subfract_visibility(False)
self.populate_warpmenu(self.f)
self.update_image_prefs(self.userPrefs)
self.statuses = [
_("Done"),
_("Calculating"),
_("Deepening (%d iterations)"),
_("Antialiasing"),
_("Paused"),
_("Reducing Periodicity Tolerance")
]
self.f.set_saved(True)
self.directorDialog = director.DirectorDialog(self.window, self.f,
self.userConfig)
self.painterDialog = painter.PainterDialog(self.window, self.f)
self.renderqueueDialog = renderqueue.QueueDialog(
self.window, self.f, self.renderQueue)
#!/usr/bin/env python3
# test cases for parfile.py
import string
import unittest
import io
import math
import sys
if sys.path[1] != "..": sys.path.insert(1, "..")
from fract4d import testbase, fractal, fractconfig, fc, preprocessor, gradient
from fractutils import parfile
g_comp = fc.Compiler(fractconfig.T(""))
g_comp.add_func_path("../formulas")
g_comp.add_func_path("../fract4d")
g_comp.load_formula_file("gf4d.frm")
g_comp.load_formula_file("test.frm")
g_comp.load_formula_file("gf4d.cfrm")
fotd = """FOTD_for_04-05-06 { ; time=2:38:57.82--SF5 on a P200
reset=2004 type=mandel passes=1
center-mag=-0.74999655467724592903865/0.0171269216\\
3034049041486/5.51789e+018 params=0/0 float=y
maxiter=72000 inside=0 periodicity=10
colors=0000qJ0mP0iX0eb0di0`o0Xu0Tz2Pz2NzRTzoZqzbRz\\
dTzdTzeTzeTzeTzgVzgVzgVziVziVzkXzkXzkXzmXzmXzmXzgV\\
zdTu`RkXP`TNRNNGJL6GJ0CH08K04U0GcAWdPdkehvpmuxrzzx\\
zzzuzzqzzmzzizzezzbzzZzzVzzTzzRzzRxzPozPexNZvNPsLG\\