def main():
  import sys, traceback
  from fn import Fn
  from sand import Sand
  from modules.helpers import get_colors

  sand = Sand(SIZE)
  sand.set_bg(BG)
  sand.set_rgba(FRONT)

  colors = get_colors('../colors/dark_cyan_white_black2.gif')
  nc = len(colors)

  fn = Fn(prefix='./res/', postfix='.png')
  si = spline_iterator()

  while True:
    try:
      itt, w, xy = next(si)
      rgba = colors[w%nc] + [0.0005]
      sand.set_rgba(rgba)
      sand.paint_dots(xy)
      if not itt%(40000):
        print(itt)
        sand.write_to_png(fn.name(), GAMMA)
    except Exception as e:
      print(e)
      sand.write_to_png(fn.name(), GAMMA)
      traceback.print_exc(file=sys.stdout)
Beispiel #2
0
def main():
    import sys, traceback
    from fn import Fn
    from sand import Sand
    from modules.helpers import get_colors

    sand = Sand(SIZE)
    sand.set_bg(BG)
    sand.set_rgba(FRONT)

    colors = get_colors('../colors/dark_cyan_white_black2.gif')
    nc = len(colors)

    fn = Fn(prefix='./res/', postfix='.png')
    si = spline_iterator()

    while True:
        try:
            itt, w, xy = next(si)
            rgba = colors[w % nc] + [0.0005]
            sand.set_rgba(rgba)
            sand.paint_dots(xy)
            if not itt % (40000):
                print(itt)
                sand.write_to_png(fn.name(), GAMMA)
        except Exception as e:
            print(e)
            sand.write_to_png(fn.name(), GAMMA)
            traceback.print_exc(file=sys.stdout)
Beispiel #3
0
def make_creatures(sand):
    from modules.creature import MultiCreature
    from numpy import array
    from modules.helpers import get_colors

    colors = get_colors('../colors/shimmering.gif')
    nc = len(colors)

    w = 0

    pnum = 4
    for i, y in enumerate(linspace(EDGE, 1.0 - EDGE, CREATURE_NUM)):
        for j, x in enumerate(linspace(EDGE, 1.0 - EDGE, CREATURE_NUM)):
            print(i, j)

            pnum = 4 + 1
            xy = array((x, y), 'float')
            size = (1.0 - 2 * EDGE) / CREATURE_NUM * 0.1
            creature = MultiCreature(pnum, INUM, STEPS, xy, size,
                                     get_displaced_multi(NOISE, 4 + j))

            w += 1
            rgba = colors[w % nc] + [0.0005]
            sand.set_rgba(rgba)

            for l1 in creature.paths():

                sand.paint_dots(l1)
Beispiel #4
0
def make_creatures(sand):
    from modules.creature import Creature
    from numpy import array
    from numpy.random import randint
    from modules.helpers import get_colors

    # colors = get_colors('../colors/shimmering.gif')
    # colors = get_colors('../colors/tumblr_nkpio2Dl4H1rlz4gso2_1280_1000.jpg')
    colors = get_colors('../colors/ray-1.jpeg')
    nc = len(colors)

    w = 0
    pnum = 4
    for i, y in enumerate(linspace(EDGE, 1.0 - EDGE, CREATURE_NUM)):
        for j, x in enumerate(linspace(EDGE, 1.0 - EDGE, CREATURE_NUM)):

            # pnum = randint(4,10)
            pnum = 4 + j
            # pnum = 5
            noise = 0.0030 + j * 0.001

            xy = array((x, y), 'float')
            size = 0.024
            creature = Creature(pnum, INUM, xy, size,
                                get_displaced_single(noise), ORDERED)
            # creature = Creature(pnum, INUM, xy, size, get_rnd_circ(), ORDERED)
            l1, l2 = creature.paths()

            w += 1
            rgba = colors[w % nc] + [0.0005]
            sand.set_rgba(rgba)

            sand.paint_strokes(l1, l2, GRAINS)
def make_creatures(sand):
  from modules.creature import MultiCreature
  from numpy import array
  from modules.helpers import get_colors

  colors = get_colors('../colors/shimmering.gif')
  nc = len(colors)

  w = 0

  pnum = 4
  for i, y in enumerate(linspace(EDGE, 1.0-EDGE, CREATURE_NUM)):
    for j, x in enumerate(linspace(EDGE, 1.0-EDGE, CREATURE_NUM)):
      print(i,j)

      pnum = 4+1
      xy = array((x, y), 'float')
      size = (1.0-2*EDGE)/CREATURE_NUM*0.1
      creature = MultiCreature(
          pnum,
          INUM,
          STEPS,
          xy,
          size,
          get_displaced_multi(NOISE, 4+j)
          )

      w += 1
      rgba = colors[w%nc] + [0.0005]
      sand.set_rgba(rgba)

      for l1 in creature.paths():

        sand.paint_dots(l1)
Beispiel #6
0
def main():
  import sys, traceback
  from fn import Fn
  from sand import Sand
  from modules.helpers import get_colors

  sand = Sand(SIZE)
  sand.set_bg(BG)
  sand.set_rgba(FRONT)

  colors = get_colors('colors/dark_cyan_white_black.gif')
  nc = len(colors)

  fn = Fn(prefix='./res/', postfix='.png')
  si = spline_iterator()

  while True:
    try:
      itt, w, xy = next(si)
      rgba = colors[w%nc] + [0.005]
      sand.set_rgba(rgba)
      sand.paint_dots(xy)
      if not itt%(50):
        print("ci:"+str(itt))
      if not itt%(5000):
        if os.path.isfile("./res/dump1.png"):
          print("printing to dump2:"+str(itt))
          sand.write_to_png("./res/dump2.png", GAMMA)
          os.remove("./res/dump1.png")
        else:
          print("printing to dump1:"+str(itt))
          sand.write_to_png("./res/dump1.png", GAMMA)
          if os.path.isfile("./res/dump2.png"):
            os.remove("./res/dump2.png")
    except Exception as e:
      print(e)
      sand.write_to_png("./res/current.png", GAMMA)
      traceback.print_exc(file=sys.stdout)
def main():
  from fn import Fn
  from modules.differentialLattice import DifferentialLattice
  from modules.helpers import get_colors
  from modules.helpers import spawn_circle
  from numpy import array
  from numpy import cumsum
  from numpy import sqrt
  from numpy import linspace
  from numpy import sort
  from numpy import ones
  from numpy.random import random
  from numpy.random import seed
  from sand import Sand
  from numpy import pi
  from numpy import sin
  from numpy import cos
  TWOPI = pi*2.0


  fn = Fn(prefix='./res/')

  size = 512
  one = 1.0/size

  threads = 512
  zone_leap = 512
  grains =  20


  init_num = 20

  stp = one*0.03
  spring_stp = 5
  reject_stp = 0.1
  cohesion_stp = 1.0

  max_capacity = 30


  node_rad = 4*one
  spring_reject_rad = node_rad*1.9
  spring_attract_rad = node_rad*2.0
  outer_influence_rad = 10.0*node_rad
  link_ignore_rad = 0.5*outer_influence_rad

  colors = get_colors('../colors/black_t.gif')
  # colors = get_colors('../colors/ir.jpg')
  nc = len(colors)

  sand = Sand(size)
  sand.set_bg(BACK)
  sand.set_rgba(FRONT)

  DL = DifferentialLattice(
      size,
      stp,
      spring_stp,
      reject_stp,
      cohesion_stp,
      max_capacity,
      node_rad,
      spring_reject_rad,
      spring_attract_rad,
      outer_influence_rad,
      link_ignore_rad,
      threads=threads,
      zone_leap=zone_leap,
      nmax=50000000
      )

  spawn_circle(DL, init_num, xy=array([[0.5, 0.5]]), dst=node_rad*0.8, rad=0.01)

  itt = 0
  while True:

    itt += 1
    DL.step()
    DL.spawn(ratio=0.1, age=1000)

    if not itt%20:
      print(('itt', DL.itt, 'num', DL.num))

    vertices, edges = DL.link_export()

    # sand.set_rgba(FRONT)
    # sand.paint_strokes(
    #     vertices[edges[:,0],:].astype('double'),
    #     vertices[edges[:,1],:].astype('double'),
    #     grains
    #     )

    # sand.paint_circles(
    #     vertices.astype('double'),
    #     random(len(vertices))*one*4.0,
    #     grains
    #     )

    # for k,(a,b) in enumerate(edges):
    #   w = a*nc+b
    #   rgba = colors[w%nc]+[0.001]
    #   sand.set_rgba(rgba)
    #   sand.paint_strokes(
    #       vertices[a:a+1,:].astype('double'),
    #       vertices[b:b+1,:].astype('double'),
    #       grains
    #       )


    n = 20
    for k, (x, y) in enumerate(vertices):
      rgba = colors[k%nc]+[0.0005]
      sand.set_rgba(rgba)
      o = ones((n, 2), 'float')
      o[:,0] *= x
      o[:,1] *= y
      r = (1.0-2.0*random(n))*4*one
      sand.paint_filled_circles(
          o,
          r,
          grains
          )

    if not itt%5:

      # vertices, edges = DL.link_export()
      # n = 1000
      # sand.set_bg(BACK)
      # seed(1)
      # for k, (x, y) in enumerate(vertices):
      #   rgba = colors[k%nc]+[0.005]
      #   sand.set_rgba(rgba)
      #   o = ones((n, 2), 'float')
      #   o[:,0] *= x
      #   o[:,1] *= y
      #   r = random()*one*3+cumsum(random(n)*random()*10)*one*0.002
      #   # r = sqrt(linspace(2.0, 10.0, n))*one
      #   # r = ones(n, 'float')*one*
      #   sand.paint_circles(
      #       o,
      #       r,
      #       grains
      #       )

      name = fn.name() + '.png'
      print(name)
      sand.write_to_png(name, 2)