anuga 1.3.5__zip

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pmesh/PmwColor.py

@@ -0,0 +1,389 @@
+"""
+Pmw copyright
+
+Copyright 1997-1999 Telstra Corporation Limited,
+Australia Copyright 2000-2002 Really Good Software Pty Ltd, Australia
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+
+
+# Functions for converting colors and modifying the color scheme of
+# an application.
+
+import math
+import string
+import sys
+import Tkinter
+
+_PI = math.pi
+_TWO_PI = _PI * 2
+_THIRD_PI = _PI / 3
+_SIXTH_PI = _PI / 6
+_MAX_RGB = float(256 * 256 - 1) # max size of rgb values returned from Tk
+
+def setscheme(root, background=None, **kw):
+    root = root._root()
+    palette = apply(_calcPalette, (root, background,), kw)
+    for option, value in palette.items():
+	root.option_add('*' + option, value, 'widgetDefault')
+
+def getdefaultpalette(root):
+    # Return the default values of all options, using the defaults
+    # from a few widgets.
+
+    ckbtn = Tkinter.Checkbutton(root)
+    entry = Tkinter.Entry(root)
+    scbar = Tkinter.Scrollbar(root)
+
+    orig = {}
+    orig['activeBackground'] = str(ckbtn.configure('activebackground')[4])
+    orig['activeForeground'] = str(ckbtn.configure('activeforeground')[4])
+    orig['background'] = str(ckbtn.configure('background')[4])
+    orig['disabledForeground'] = str(ckbtn.configure('disabledforeground')[4])
+    orig['foreground'] = str(ckbtn.configure('foreground')[4])
+    orig['highlightBackground'] = str(ckbtn.configure('highlightbackground')[4])
+    orig['highlightColor'] = str(ckbtn.configure('highlightcolor')[4])
+    orig['insertBackground'] = str(entry.configure('insertbackground')[4])
+    orig['selectColor'] = str(ckbtn.configure('selectcolor')[4])
+    orig['selectBackground'] = str(entry.configure('selectbackground')[4])
+    orig['selectForeground'] = str(entry.configure('selectforeground')[4])
+    orig['troughColor'] = str(scbar.configure('troughcolor')[4])
+
+    ckbtn.destroy()
+    entry.destroy()
+    scbar.destroy()
+
+    return orig
+
+#======================================================================
+
+# Functions dealing with brightness, hue, saturation and intensity of colors.
+
+def changebrightness(root, colorName, brightness):
+    # Convert the color name into its hue and back into a color of the
+    # required brightness.
+
+    rgb = name2rgb(root, colorName)
+    hue, saturation, intensity = rgb2hsi(rgb)
+    if saturation == 0.0:
+        hue = None
+    return hue2name(hue, brightness)
+
+def hue2name(hue, brightness = None):
+    # Convert the requested hue and brightness into a color name.  If
+    # hue is None, return a grey of the requested brightness.
+
+    if hue is None:
+	rgb = hsi2rgb(0.0, 0.0, brightness)
+    else:
+	while hue < 0:
+	    hue = hue + _TWO_PI
+	while hue >= _TWO_PI:
+	    hue = hue - _TWO_PI
+
+	rgb = hsi2rgb(hue, 1.0, 1.0)
+	if brightness is not None:
+	    b = rgb2brightness(rgb)
+	    i = 1.0 - (1.0 - brightness) * b
+	    s = bhi2saturation(brightness, hue, i)
+	    rgb = hsi2rgb(hue, s, i)
+
+    return rgb2name(rgb)
+
+def bhi2saturation(brightness, hue, intensity):
+    while hue < 0:
+        hue = hue + _TWO_PI
+    while hue >= _TWO_PI:
+        hue = hue - _TWO_PI
+    hue = hue / _THIRD_PI
+    f = hue - math.floor(hue)
+
+    pp = intensity
+    pq = intensity * f
+    pt = intensity - intensity * f
+    pv = 0
+
+    hue = int(hue)
+    if   hue == 0: rgb = (pv, pt, pp)
+    elif hue == 1: rgb = (pq, pv, pp)
+    elif hue == 2: rgb = (pp, pv, pt)
+    elif hue == 3: rgb = (pp, pq, pv)
+    elif hue == 4: rgb = (pt, pp, pv)
+    elif hue == 5: rgb = (pv, pp, pq)
+
+    return (intensity - brightness) / rgb2brightness(rgb)
+
+def hsi2rgb(hue, saturation, intensity):
+    i = intensity
+    if saturation == 0:
+	rgb = [i, i, i]
+    else:
+	while hue < 0:
+	    hue = hue + _TWO_PI
+	while hue >= _TWO_PI:
+	    hue = hue - _TWO_PI
+	hue = hue / _THIRD_PI
+	f = hue - math.floor(hue)
+	p = i * (1.0 - saturation)
+	q = i * (1.0 - saturation * f)
+	t = i * (1.0 - saturation * (1.0 - f))
+
+	hue = int(hue)
+	if   hue == 0: rgb = [i, t, p]
+	elif hue == 1: rgb = [q, i, p]
+	elif hue == 2: rgb = [p, i, t]
+	elif hue == 3: rgb = [p, q, i]
+	elif hue == 4: rgb = [t, p, i]
+	elif hue == 5: rgb = [i, p, q]
+
+    for index in range(3):
+	val = rgb[index]
+	if val < 0.0:
+	    val = 0.0
+	if val > 1.0:
+	    val = 1.0
+	rgb[index] = val
+
+    return rgb
+
+def average(rgb1, rgb2, fraction):
+    return (
+	rgb2[0] * fraction + rgb1[0] * (1.0 - fraction),
+	rgb2[1] * fraction + rgb1[1] * (1.0 - fraction),
+	rgb2[2] * fraction + rgb1[2] * (1.0 - fraction)
+    )
+
+def rgb2name(rgb):
+    return '#%02x%02x%02x' % \
+        (int(rgb[0] * 255), int(rgb[1] * 255), int(rgb[2] * 255))
+
+def rgb2brightness(rgb):
+    # Return the perceived grey level of the color
+    # (0.0 == black, 1.0 == white).
+
+    rf = 0.299
+    gf = 0.587
+    bf = 0.114
+    return rf * rgb[0] + gf * rgb[1] + bf * rgb[2]
+
+def rgb2hsi(rgb):
+    maxc = max(rgb[0], rgb[1], rgb[2])
+    minc = min(rgb[0], rgb[1], rgb[2])
+
+    intensity = maxc
+    if maxc != 0:
+      saturation  = (maxc - minc) / maxc
+    else:
+      saturation = 0.0
+
+    hue = 0.0
+    if saturation != 0.0:
+	c = []
+	for index in range(3):
+	    c.append((maxc - rgb[index]) / (maxc - minc))
+
+	if rgb[0] == maxc:
+	    hue = c[2] - c[1]
+	elif rgb[1] == maxc:
+	    hue = 2 + c[0] - c[2]
+	elif rgb[2] == maxc:
+	    hue = 4 + c[1] - c[0]
+
+	hue = hue * _THIRD_PI
+	if hue < 0.0:
+	    hue = hue + _TWO_PI
+
+    return (hue, saturation, intensity)
+
+def name2rgb(root, colorName, asInt = 0):
+    if colorName[0] == '#':
+	# Extract rgb information from the color name itself, assuming
+	# it is either #rgb, #rrggbb, #rrrgggbbb, or #rrrrggggbbbb
+	# This is useful, since tk may return incorrect rgb values if
+	# the colormap is full - it will return the rbg values of the
+	# closest color available.
+        colorName = colorName[1:]
+        digits = len(colorName) / 3
+        factor = 16 ** (4 - digits)
+        rgb = (
+            string.atoi(colorName[0:digits], 16) * factor,
+            string.atoi(colorName[digits:digits * 2], 16) * factor,
+            string.atoi(colorName[digits * 2:digits * 3], 16) * factor,
+        )
+    else:
+	# We have no choice but to ask Tk what the rgb values are.
+	rgb = root.winfo_rgb(colorName)
+
+    if not asInt:
+        rgb = (rgb[0] / _MAX_RGB, rgb[1] / _MAX_RGB, rgb[2] / _MAX_RGB)
+    return rgb
+
+def _calcPalette(root, background=None, **kw):
+    # Create a map that has the complete new palette.  If some colors
+    # aren't specified, compute them from other colors that are specified.
+    new = {}
+    for key, value in kw.items():
+	new[key] = value
+    if background is not None:
+	new['background'] = background
+    if not new.has_key('background'):
+	raise ValueError, 'must specify a background color'
+
+    if not new.has_key('foreground'):
+	new['foreground'] = 'black'
+
+    bg = name2rgb(root, new['background'])
+    fg = name2rgb(root, new['foreground'])
+
+    for i in ('activeForeground', 'insertBackground', 'selectForeground',
+	    'highlightColor'):
+	if not new.has_key(i):
+	    new[i] = new['foreground']
+
+    if not new.has_key('disabledForeground'):
+	newCol = average(bg, fg, 0.3)
+	new['disabledForeground'] = rgb2name(newCol)
+
+    if not new.has_key('highlightBackground'):
+	new['highlightBackground'] = new['background']
+
+    # Set <lighterBg> to a color that is a little lighter that the
+    # normal background.  To do this, round each color component up by
+    # 9% or 1/3 of the way to full white, whichever is greater.
+    lighterBg = []
+    for i in range(3):
+	lighterBg.append(bg[i])
+	inc1 = lighterBg[i] * 0.09
+	inc2 = (1.0 - lighterBg[i]) / 3
+	if inc1 > inc2:
+	    lighterBg[i] = lighterBg[i] + inc1
+	else:
+	    lighterBg[i] = lighterBg[i] + inc2
+	if lighterBg[i] > 1.0:
+	    lighterBg[i] = 1.0
+
+    # Set <darkerBg> to a color that is a little darker that the
+    # normal background.
+    darkerBg = (bg[0] * 0.9, bg[1] * 0.9, bg[2] * 0.9)
+
+    if not new.has_key('activeBackground'):
+	# If the foreground is dark, pick a light active background.
+	# If the foreground is light, pick a dark active background.
+	# XXX This has been disabled, since it does not look very
+	# good with dark backgrounds. If this is ever fixed, the
+	# selectBackground and troughColor options should also be fixed.
+
+	if rgb2brightness(fg) < 0.5:
+	    new['activeBackground'] = rgb2name(lighterBg)
+	else:
+	    new['activeBackground'] = rgb2name(lighterBg)
+
+    if not new.has_key('selectBackground'):
+	new['selectBackground'] = rgb2name(darkerBg)
+    if not new.has_key('troughColor'):
+	new['troughColor'] = rgb2name(darkerBg)
+    if not new.has_key('selectColor'):
+	new['selectColor'] = 'yellow'
+
+    return new
+
+def spectrum(numColors, correction = 1.0, saturation = 1.0, intensity = 1.0,
+	extraOrange = 1, returnHues = 0):
+    colorList = []
+    division = numColors / 7.0
+    for index in range(numColors):
+	if extraOrange:
+	    if index < 2 * division:
+		hue = index / division
+	    else:
+		hue = 2 + 2 * (index - 2 * division) / division
+	    hue = hue * _SIXTH_PI
+	else:
+	    hue = index * _TWO_PI / numColors
+	if returnHues:
+	    colorList.append(hue)
+	else:
+	    rgb = hsi2rgb(hue, saturation, intensity)
+	    if correction != 1.0:
+		rgb = correct(rgb, correction)
+	    name = rgb2name(rgb)
+	    colorList.append(name)
+    return colorList
+
+def correct(rgb, correction):
+    correction = float(correction)
+    rtn = []
+    for index in range(3):
+	rtn.append((1 - (1 - rgb[index]) ** correction) ** (1 / correction))
+    return rtn
+
+#==============================================================================
+
+def _recolorTree(widget, oldpalette, newcolors):
+    # Change the colors in a widget and its descendants.
+
+    # Change the colors in <widget> and all of its descendants,
+    # according to the <newcolors> dictionary.  It only modifies
+    # colors that have their default values as specified by the
+    # <oldpalette> variable.  The keys of the <newcolors> dictionary
+    # are named after widget configuration options and the values are
+    # the new value for that option.
+
+    for dbOption in newcolors.keys():
+        option = string.lower(dbOption)
+        try:
+            value = str(widget.cget(option))
+        except:
+            continue
+        if oldpalette is None or value == oldpalette[dbOption]:
+            apply(widget.configure, (), {option : newcolors[dbOption]})
+
+    for child in widget.winfo_children():
+       _recolorTree(child, oldpalette, newcolors)
+
+def changecolor(widget, background=None, **kw):
+     root = widget._root()
+     if not hasattr(widget, '_Pmw_oldpalette'):
+	 widget._Pmw_oldpalette = getdefaultpalette(root)
+     newpalette = apply(_calcPalette, (root, background,), kw)
+     _recolorTree(widget, widget._Pmw_oldpalette, newpalette)
+     widget._Pmw_oldpalette = newpalette
+
+def bordercolors(root, colorName):
+    # This is the same method that Tk uses for shadows, in TkpGetShadows.
+
+    lightRGB = []
+    darkRGB = []
+    for value in name2rgb(root, colorName, 1):
+        value40pc = (14 * value) / 10
+        if value40pc > _MAX_RGB:
+            value40pc = _MAX_RGB
+        valueHalfWhite = (_MAX_RGB + value) / 2;
+        lightRGB.append(max(value40pc, valueHalfWhite))
+
+        darkValue = (60 * value) / 100
+        darkRGB.append(darkValue)
+
+    return (
+        '#%04x%04x%04x' % (lightRGB[0], lightRGB[1], lightRGB[2]),
+        '#%04x%04x%04x' % (darkRGB[0], darkRGB[1], darkRGB[2])
+    )

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pmesh/ProgressBar.py

@@ -0,0 +1,80 @@
+"""
+A  basic widget for showing the progress
+being made in a task.
+
+"""
+
+from Tkinter import *
+
+class ProgressBar:
+    def __init__(self, master=None, orientation="horizontal",
+                 min=0, max=100, width=100, height=18,
+                 doLabel=1, appearance="sunken",
+		 fillColor="blue", background="gray",
+                 labelColor="yellow", labelFont="Verdana",
+                 labelText="", labelFormat="%d%%",
+                 value=50, bd=2):
+	# preserve various values
+	self.master=master
+	self.orientation=orientation
+	self.min=min
+	self.max=max
+	self.width=width
+	self.height=height
+	self.doLabel=doLabel
+	self.fillColor=fillColor
+        self.labelFont= labelFont
+	self.labelColor=labelColor
+	self.background=background
+	self.labelText=labelText
+	self.labelFormat=labelFormat
+	self.value=value
+	self.frame=Frame(master, relief=appearance, bd=bd)
+	self.canvas=Canvas(self.frame, height=height, width=width, bd=0,
+                           highlightthickness=0, background=background)
+	self.scale=self.canvas.create_rectangle(0, 0, width, height,
+						fill=fillColor)
+	self.label=self.canvas.create_text(self.canvas.winfo_reqwidth() / 2,
+					   height / 2, text=labelText,
+					   anchor="c", fill=labelColor,
+					   font=self.labelFont)
+	self.update()
+	self.canvas.pack(side='top', fill='x', expand='no')
+
+    def updateProgress(self, newValue, newMax=None):
+        if newMax:
+            self.max = newMax
+        self.value = newValue
+        self.update()
+
+    def update(self):
+	# Trim the values to be between min and max
+	value=self.value
+	if value > self.max:
+	    value = self.max
+	if value < self.min:
+	    value = self.min
+	# Adjust the rectangle
+	if self.orientation == "horizontal":
+	    self.canvas.coords(self.scale, 0, 0,
+		     float(value) / self.max * self.width, self.height)
+	else:
+	    self.canvas.coords(self.scale, 0,
+                     self.height - (float(value) / self.max*self.height),
+		     self.width, self.height)
+	# Now update the colors
+	self.canvas.itemconfig(self.scale, fill=self.fillColor)
+	self.canvas.itemconfig(self.label, fill=self.labelColor)
+	# And update the label
+	if self.doLabel:
+            if value:
+                if value >= 0:
+                    pvalue = int((float(value) / float(self.max)) * 100.0)
+                else:
+                    value = 0
+                self.canvas.itemconfig(self.label, text=self.labelFormat % value)
+            else:
+                self.canvas.itemconfig(self.label, text='')
+	else:
+	    self.canvas.itemconfig(self.label, text=self.labelFormat % self.labelText)
+	self.canvas.update_idletasks()

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pmesh/__init__.py

@@ -0,0 +1,4 @@
+#nothing
+
+from numpy.testing import Tester
+test = Tester().test

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pmesh/compile.py

@@ -0,0 +1,24 @@
+"""compile.py - compile Python C-extension
+
+   Commandline usage: 
+     python compile.py <filename>
+ 
+"""     
+import os
+
+buildroot = os.getcwd()
+os.chdir('..')
+
+
+print 'Changing to', os.getcwd()        
+
+#entries = listdir('.')
+
+#Attempt to compile mesh_engine extensions
+
+
+os.chdir('mesh_engine')
+execfile('..' + os.sep + 'utilities' + os.sep + 'compile.py')
+
+os.chdir(buildroot)   
+    

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pmesh/cursornames.py

@@ -0,0 +1,8 @@
+TLC = 'top_left_corner'
+TRC = 'top_right_corner'
+BLC = 'bottom_left_corner'
+BRC = 'bottom_right_corner'
+TS  = 'top_side'
+RS  = 'right_side'
+LS  = 'left_side'
+BS  = 'bottom_side'

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/pmesh/exesetup.py

@@ -0,0 +1,24 @@
+# setup.py
+#run with "python exesetup.py py2exe"
+from distutils.core import setup
+import py2exe
+      
+setup(console=["pmesh.py"],
+      data_files=[("icons",
+                   ["icons/addVertex.gif",
+                    "icons/autoSeg.gif",
+                    "icons/edit.gif",
+                    "icons/hole.gif",
+                    "icons/joinVer.gif",
+                    "icons/meshGen.gif",
+                    "icons/pointer.gif",
+                    "icons/default.gif",
+                    "icons/region.gif",
+                    "icons/segment.gif",
+                    "icons/sep.gif",
+                    "icons/vertex.gif",
+                    "icons/zoom0.5.gif",
+                    "icons/zoom1.0.gif",
+                    "icons/zoom2.gif",
+                    "icons/zoomToMesh.gif"]),
+                  (".",["./hull.exe"])])