home *** CD-ROM | disk | FTP | other *** search
/ Hackers Magazine 57 / CdHackersMagazineNr57.iso / Software / Multimedia / k3d-setup-0.7.11.0.exe / lib / site-packages / cgkit / noise.py < prev    next >
Encoding:
Python Source  |  2007-01-11  |  8.4 KB  |  282 lines
  1. # ***** BEGIN LICENSE BLOCK *****
  2. # Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3. #
  4. # The contents of this file are subject to the Mozilla Public License Version
  5. # 1.1 (the "License"); you may not use this file except in compliance with
  6. # the License. You may obtain a copy of the License at
  7. # http://www.mozilla.org/MPL/
  8. #
  9. # Software distributed under the License is distributed on an "AS IS" basis,
  10. # WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11. # for the specific language governing rights and limitations under the
  12. # License.
  13. #
  14. # The Original Code is the Python Computer Graphics Kit.
  15. #
  16. # The Initial Developer of the Original Code is Matthias Baas.
  17. # Portions created by the Initial Developer are Copyright (C) 2004
  18. # the Initial Developer. All Rights Reserved.
  19. #
  20. # Contributor(s):
  21. #
  22. # Alternatively, the contents of this file may be used under the terms of
  23. # either the GNU General Public License Version 2 or later (the "GPL"), or
  24. # the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  25. # in which case the provisions of the GPL or the LGPL are applicable instead
  26. # of those above. If you wish to allow use of your version of this file only
  27. # under the terms of either the GPL or the LGPL, and not to allow others to
  28. # use your version of this file under the terms of the MPL, indicate your
  29. # decision by deleting the provisions above and replace them with the notice
  30. # and other provisions required by the GPL or the LGPL. If you do not delete
  31. # the provisions above, a recipient may use your version of this file under
  32. # the terms of any one of the MPL, the GPL or the LGPL.
  33. #
  34. # ***** END LICENSE BLOCK *****
  35. # $Id: noise.py,v 1.3 2006/02/14 19:29:39 mbaas Exp $
  36.  
  37. """This module contains various noise functions.
  38. """
  39.  
  40. from _core import noise, snoise, cellnoise, scellnoise, fBm, turbulence
  41. from _core import pnoise as _pnoise
  42. from _core import spnoise as _spnoise
  43. from _core import vnoise, vsnoise, vcellnoise, vscellnoise, vfBm, vturbulence
  44. from _core import vpnoise as _vpnoise
  45. from _core import vspnoise as _vspnoise
  46. from cgtypes import vec3
  47.  
  48. # pnoise
  49. def pnoise(*args):
  50.     """pnoise(point, period) / pnoise(point, t, pperiod, tperiod) -> float
  51.  
  52.     Periodic noise function. Basically this is the same than noise
  53.     but with a periodic return value: pnoise(point) = pnoise(point+period).
  54.     The time value can be either part of the point or it can be
  55.     specified separately. The point and period must always have the
  56.     same dimension. The return value is in the range from 0 to 1.
  57.     """
  58.     
  59.     n = len(args)
  60.     if n==2:
  61.         v, pv = args
  62.         try:
  63.             m = len(v)
  64.         except:
  65.             return _pnoise(v, 0, pv, 1)
  66.         if m==1:
  67.             return _pnoise(v[0], 0, pv[0], 1)
  68.         elif m==2:
  69.             x,y = v
  70.             px,py = pv
  71.             return _pnoise(x,y,px,py)
  72.         elif m==3:
  73.             x,y,z = v
  74.             px,py,pz = pv
  75.             return _pnoise(x,y,z,px,py,pz)
  76.         elif m==4:
  77.             x,y,z,t = v
  78.             px,py,pz,pt = pv
  79.             return _pnoise(x,y,z,t,px,py,pz,pt)
  80.         else:
  81.             raise ValueError, "Invalid arguments"
  82.         
  83.     elif n==4:
  84.         v,t,pv,pt = args
  85.         try:
  86.             m = len(v)
  87.         except:
  88.             return _pnoise(v, t, pv, pt)
  89.         if m==1:
  90.             return _pnoise(v[0], t, pv[0], pt)
  91.         elif m==2:
  92.             x,y = v
  93.             px,py = pv
  94.             return _pnoise(x,y,t,px,py,pt)
  95.         elif m==3:
  96.             x,y,z = v
  97.             px,py,pz = pv
  98.             return _pnoise(x,y,z,t,px,py,pz,pt)
  99.         else:
  100.             raise ValueError, "Invalid arguments"
  101.     
  102.     else:
  103.         raise TypeError, "only 2 or 4 arguments allowed"
  104.  
  105.  
  106. # spnoise
  107. def spnoise(*args):
  108.     """spnoise(point, period) / spnoise(point, t, pperiod, tperiod) -> float
  109.  
  110.     Signed periodic noise function. The return value is in the range
  111.     from -1 to 1. A call to spnoise(args) is equivalent to
  112.     2*pnoise(args)-1.
  113.     """
  114.     
  115.     n = len(args)
  116.     if n==2:
  117.         v, pv = args
  118.         try:
  119.             m = len(v)
  120.         except:
  121.             return _spnoise(v, 0, pv, 1)
  122.         if m==1:
  123.             return _spnoise(v[0], 0, pv[0], 1)
  124.         elif m==2:
  125.             x,y = v
  126.             px,py = pv
  127.             return _spnoise(x,y,px,py)
  128.         elif m==3:
  129.             x,y,z = v
  130.             px,py,pz = pv
  131.             return _spnoise(x,y,z,px,py,pz)
  132.         elif m==4:
  133.             x,y,z,t = v
  134.             px,py,pz,pt = pv
  135.             return _spnoise(x,y,z,t,px,py,pz,pt)
  136.         else:
  137.             raise ValueError, "Invalid arguments"
  138.         
  139.     elif n==4:
  140.         v,t,pv,pt = args
  141.         try:
  142.             m = len(v)
  143.         except:
  144.             return _spnoise(v, t, pv, pt)
  145.         if m==1:
  146.             return _spnoise(v[0], t, pv[0], pt)
  147.         elif m==2:
  148.             x,y = v
  149.             px,py = pv
  150.             return _spnoise(x,y,t,px,py,pt)
  151.         elif m==3:
  152.             x,y,z = v
  153.             px,py,pz = pv
  154.             return _spnoise(x,y,z,t,px,py,pz,pt)
  155.         else:
  156.             raise ValueError, "Invalid arguments"
  157.     
  158.     else:
  159.         raise TypeError, "only 2 or 4 arguments allowed"
  160.  
  161.  
  162. # vpnoise
  163. def vpnoise(*args):
  164.     """vpnoise(point, period) / vpnoise(point, t, pperiod, tperiod) -> noiseval
  165.  
  166.     Periodic noise function. Basically this is the same than vnoise
  167.     but with a periodic return value: vpnoise(point) = vpnoise(point+period).
  168.     The time value can be either part of the point or it can be
  169.     specified separately. The point and period must always have the
  170.     same dimension. The components of the return value are in the range
  171.     from 0 to 1.
  172.     """
  173.     
  174.     n = len(args)
  175.     if n==2:
  176.         v, pv = args
  177.         try:
  178.             m = len(v)
  179.         except:
  180.             return _vpnoise(v, pv)
  181.         if m==1:
  182.             return _vpnoise(v[0], pv[0])
  183.         elif m==2:
  184.             x,y = v
  185.             px,py = pv
  186.             return _vpnoise(x,y,px,py)
  187.         elif m==3:
  188.             x,y,z = v
  189.             px,py,pz = pv
  190.             return _vpnoise(x,y,z,px,py,pz)
  191.         elif m==4:
  192.             x,y,z,t = v
  193.             px,py,pz,pt = pv
  194.             return _vpnoise(x,y,z,t,px,py,pz,pt)
  195.         else:
  196.             raise ValueError, "Invalid arguments"
  197.         
  198.     elif n==4:
  199.         v,t,pv,pt = args
  200.         try:
  201.             m = len(v)
  202.         except:
  203.             return _vpnoise(v, t, pv, pt)
  204.         if m==1:
  205.             return _vpnoise(v[0], t, pv[0], pt)
  206.         elif m==2:
  207.             x,y = v
  208.             px,py = pv
  209.             return _vpnoise(x,y,t,px,py,pt)
  210.         elif m==3:
  211.             x,y,z = v
  212.             px,py,pz = pv
  213.             res = _vpnoise(x,y,z,t,px,py,pz,pt)
  214.             return vec3(res.x, res.y, res.z)
  215.         else:
  216.             raise ValueError, "Invalid arguments"
  217.     
  218.     else:
  219.         raise TypeError, "only 2 or 4 arguments allowed"
  220.  
  221.  
  222. # vspnoise
  223. def vspnoise(*args):
  224.     """vspnoise(point, period) / vspnoise(point, t, pperiod, tperiod) -> noiseval
  225.  
  226.     Periodic noise function. Basically this is the same than vsnoise
  227.     but with a periodic return value: vspnoise(point) = vspnoise(point+period).
  228.     The time value can be either part of the point or it can be
  229.     specified separately. The point and period must always have the
  230.     same dimension. The components of the return value are in the range
  231.     from -1 to 1.
  232.     """
  233.     
  234.     n = len(args)
  235.     if n==2:
  236.         v, pv = args
  237.         try:
  238.             m = len(v)
  239.         except:
  240.             return _vspnoise(v, pv)
  241.         if m==1:
  242.             return _vspnoise(v[0], pv[0])
  243.         elif m==2:
  244.             x,y = v
  245.             px,py = pv
  246.             return _vspnoise(x,y,px,py)
  247.         elif m==3:
  248.             x,y,z = v
  249.             px,py,pz = pv
  250.             return _vspnoise(x,y,z,px,py,pz)
  251.         elif m==4:
  252.             x,y,z,t = v
  253.             px,py,pz,pt = pv
  254.             return _vspnoise(x,y,z,t,px,py,pz,pt)
  255.         else:
  256.             raise ValueError, "Invalid arguments"
  257.         
  258.     elif n==4:
  259.         v,t,pv,pt = args
  260.         try:
  261.             m = len(v)
  262.         except:
  263.             return _vspnoise(v, t, pv, pt)
  264.         if m==1:
  265.             return _vspnoise(v[0], t, pv[0], pt)
  266.         elif m==2:
  267.             x,y = v
  268.             px,py = pv
  269.             return _vspnoise(x,y,t,px,py,pt)
  270.         elif m==3:
  271.             x,y,z = v
  272.             px,py,pz = pv
  273.             res = _vspnoise(x,y,z,t,px,py,pz,pt)
  274.             return vec3(res.x, res.y, res.z)
  275.         else:
  276.             raise ValueError, "Invalid arguments"
  277.     
  278.     else:
  279.         raise TypeError, "only 2 or 4 arguments allowed"
  280.  
  281.  
  282.