def main():

    # Make some data first:

    n = 3600
    s = 50

    m =  -0.97
    # try various m: 0.4, 2.48, -1.383, -2.03, ...

    m = math.exp(m)
    k = 1

    xyz = [np.array([0, s * (math.e - 2), 0])]

    t = 0
    while t < n:
        rad = math.pi * t / 180
        f = s * (math.exp(math.cos(rad)) - 2 * math.cos(4 * rad) - math.pow(math.sin(rad/m), 5))
        xyz.append(np.array([f * math.sin(rad), f * math.cos(rad), f * math.sin(2*rad)]))
        t += k

    r = np.linalg.norm(xyz, axis=1)
    r = 5 - (5 / r.max()) * r + 0.02

    # Create the plots:

    optix = TkOptiX() # create and configure, show the window later

    optix.set_background(0.99) # white background
    optix.set_ambient(0.2)     # dim ambient light

    # add plot, BezierChain geometry makes a smooth line interpolating data points
    optix.set_data("curve", pos=xyz, r=r, c=0.9, geom="BezierChain")

    # show the UI window here - this method is calling some default
    # initialization for us, e.g. creates camera, so any modification
    # of these defaults should come below (or we provide on_initialization
    # callback)
    optix.show()

    # camera auto-configured to fit the plot
    optix.camera_fit()

    # 2 spherical light sources, warm and cool, fit positions with respect to
    # the current camera plane: 45 deg right/left and 25 deg up;
    # do not include lights in geometry, so they do not appear in the image
    optix.setup_light("light1", color=15*np.array([0.99, 0.9, 0.7]), radius=250, in_geometry=False)
    optix.light_fit("light1", horizontal_rot=45, vertical_rot=25, dist_scale=1.1)
    optix.setup_light("light2", color=20*np.array([0.7, 0.9, 0.99]), radius=200, in_geometry=False)
    optix.light_fit("light2", horizontal_rot=-45, vertical_rot=25, dist_scale=1.1)

    # accumulate up to 30 frames (override default of 4 frames)
    optix.set_param(max_accumulation_frames=200)

    print("done")
Example #2
0
def main():
    rt = TkOptiX()

    n = 1000000  # 1M data points

    xyz = 3 * (np.random.random((n, 3)) - 0.5)
    r = 0.02 * np.random.random(n) + 0.002

    rt.set_data("plot", xyz, r=r)

    rt.set_ambient(0.9)
    # set ambient light, brighter than default

    rt.show()  # note: non-blocking in the interactive shell

    print("done")
Example #3
0
def main():

    # Make some data first:

    n = 50000

    xyz = 3 * (np.random.random((n, 3)) - 0.5)
    r = 0.1 * (1 - (xyz[:, 0] / 3 + 0.5)) + 0.02
    s = np.sum(xyz, axis=1)

    particles = xyz[s > 0.2]
    rp = r[s > 0.2]
    # Use xyz positions to calculate RGB color components:
    cp = particles / 3 + 0.5

    cubes = xyz[s < -0.2]
    rc = r[s < -0.2]
    # Map Y-coordinate to matplotlib's color map RdYlBu: map_to_colors()
    # function is automatically scaling the data to fit <0; 1> range.
    # Any other mapping is OK, just keep the result in shape
    # (n-data-points, 3), where 3 stands for RGB color
    # components.
    cc = map_to_colors(cubes[:, 1], "RdYlBu")

    # Create plots:

    optix = TkOptiX()  # create and configure, show the window later

    # accumulate up to 30 frames (override default of 4 frames)
    optix.set_param(max_accumulation_frames=30)

    # white background
    optix.set_background(0.99)

    # add plots, ParticleSet geometry is default
    optix.set_data("particles", pos=particles, r=rp, c=cp)
    # and use geom parameter to specify cubes geometry;
    # Parallelepipeds can be described precisely with U, V, W vectors,
    # but here we only provide the r parameter - this results with
    # randomly rotated cubes of U, V, W lenghts equal to r
    optix.set_data("cubes", pos=cubes, r=rc, c=cc, geom="Parallelepipeds")

    # tetrahedrons look good as well, and they are really fast on RTX devices:
    #optix.set_data("tetras", pos=cubes, r=rc, c=cc, geom="Tetrahedrons")

    # if you prefer cubes aligned with xyz:
    #optix.set_data("cubes", pos=cubes, r=rc, c=cc, geom="Parallelepipeds", rnd=False)

    # or if you'd like some edges fixed:
    #v = np.zeros((rc.shape[0], 3)); v[:,1] = rc[:]
    #optix.set_data("cubes", pos=cubes, u=[0.05,0,0], v=v, w=[0,0,0.05], c=cc, geom="Parallelepipeds")

    # show coordinates box
    optix.set_coordinates()

    # show the UI window here - this method is calling some default
    # initialization for us, e.g. creates camera, so any modification
    # of these defaults should come below (or we provide on_initialization
    # callback)
    optix.show()

    # camera and lighting configured by hand
    optix.update_camera(eye=[5, 0, -8])
    optix.setup_light("light1",
                      color=10 * np.array([0.99, 0.9, 0.7]),
                      radius=2)

    print("done")
Example #4
0
def main():

    # Make some data first (arbitrary scles):

    data = np.random.normal(2, 0.8, 1000)
    h, x = np.histogram(data, bins=15, range=(0, 4))
    s = np.cumsum(h) / np.sum(h)
    e = 6 * np.sqrt(h) / np.sum(h)
    h = 3 * h / np.sum(h)
    bin_size = x[1] - x[0]

    # Create the plot:
    optix = TkOptiX()  # create and configure, show the window later

    # accumulate more frames (override default of step=1 and max=4 frames)
    optix.set_param(min_accumulation_step=2, max_accumulation_frames=100)

    # Add data:
    # - pos argument is used for bar positions
    # - u and w vectors are used to set base x and z sizes
    # - v is used to set bar heights.

    ps = np.zeros((h.shape[0], 3))
    ps[:, 0] = x[:-1]
    vs = np.zeros((h.shape[0], 3))
    vs[:, 1] = s
    optix.set_data("cumulative",
                   pos=ps,
                   u=[0.9 * bin_size, 0, 0],
                   v=vs,
                   w=[0, 0, 0.8 * bin_size],
                   c=[0.6, 0, 0],
                   geom="Parallelepipeds")

    ph = np.zeros((h.shape[0], 3))
    ph[:, 0] = x[:-1]
    ph[:, 2] = bin_size
    vh = np.zeros((h.shape[0], 3))
    vh[:, 1] = h
    optix.set_data("density",
                   pos=ph,
                   u=[0.9 * bin_size, 0, 0],
                   v=vh,
                   w=[0, 0, 0.8 * bin_size],
                   c=0.95,
                   geom="Parallelepipeds")

    pe = np.zeros((e.shape[0], 3))
    pe[:, 0] = x[:-1]
    pe[:, 1] = h
    pe[:, 2] = bin_size
    ve = np.zeros((e.shape[0], 3))
    ve[:, 1] = e
    optix.set_data("error",
                   pos=pe,
                   u=[0.9 * bin_size, 0, 0],
                   v=ve,
                   w=[0, 0, 0.8 * bin_size],
                   c=map_to_colors(e, "Blues"),
                   geom="Parallelepipeds")

    # Setup camera and light:
    optix.setup_camera("cam",
                       eye=[x[0], 1.5 * np.amax((h, s + e)), x[-1] - x[0]],
                       target=[(x[0] + x[-1]) / 2, 0, 0])
    optix.setup_light("l1", color=10)

    # show the UI window
    optix.show()

    print("done")
Example #5
0
def main():
    b = 7000  # number of curves
    n = 60  # number pf nodes per curve
    dt = 0.08  # nodes distance

    ofs = 50 * np.random.rand(3)
    inp = 5 * np.random.rand(b, 3, 4) - 2.5
    for c in range(b):
        inp[c, 1:, :3] = inp[c, 0, :3]
        inp[c, :, 0] *= 1.75  # more spread in X
        inp[c, :, 3] = ofs  # sync the 4'th dim of the noise
    #print(inp)

    pos = np.zeros((b, n, 3), dtype=np.float32)
    r = np.zeros((b, n), dtype=np.float32)

    rnd = simplex(inp)
    #print(rnd)

    for t in range(n):
        rt = 2.0 * (t + 1) / (n + 2) - 1
        rt = 1 - rt * rt
        r[:, t] = 0.07 * rt * rt
        for c in range(b):
            mag = np.linalg.norm(rnd[c])
            r[c, t] *= 0.2 + 0.8 * mag  # modulate thickness

            rnd[c] = (dt / mag) * rnd[c]  # normalize and scale the step size
            inp[c, :, :3] += rnd[c]  # step in the field direction
            pos[c, t] = inp[c, 0, :3]

        rnd = simplex(inp, rnd)  # calculate noise at the next pos

    rt = TkOptiX(start_now=False)
    rt.set_param(
        min_accumulation_step=1,
        max_accumulation_frames=200,
        rt_timeout=100000  # accept lower fps
    )

    exposure = 1.2
    gamma = 1.8
    rt.set_float("tonemap_exposure", exposure)
    rt.set_float("tonemap_gamma", gamma)
    rt.set_float("denoiser_blend", 0.25)
    rt.add_postproc("Denoiser")

    rt.setup_material("plastic", m_plastic)

    for c in range(b):
        if np.random.uniform() < 0.05:
            rt.set_data("c" + str(c),
                        pos=pos[c],
                        r=1.1 * r[c],
                        c=[0.4, 0, 0],
                        geom="BezierChain")
        else:
            rt.set_data("c" + str(c),
                        pos=pos[c],
                        r=r[c],
                        c=0.94,
                        geom="BezierChain",
                        mat="plastic")

    rt.setup_camera("dof_cam",
                    eye=[0, 0, 12],
                    target=[0, 0, 0],
                    fov=57,
                    focal_scale=0.7,
                    cam_type="DoF")

    rt.setup_light("l1",
                   pos=[8, -3, 13],
                   color=1.5 * np.array([0.99, 0.97, 0.93]),
                   radius=5)
    rt.setup_light("l2",
                   pos=[-17, -7, 5],
                   u=[0, 0, -10],
                   v=[0, 14, 0],
                   color=1 * np.array([0.25, 0.28, 0.35]),
                   light_type="Parallelogram")
    rt.set_ambient([0.05, 0.07, 0.09])
    rt.set_background(0)
    rt.show()

    print("done")
# plot.setup_light("l1", color=1*np.array([0.99, 0.95, 0.9]), radius=3)
plot.set_background(fname)
plot.set_ambient(0.1)

# for i in range(1,6):
# points = np.load(input_path+str(i)+".npz","r+")["arr_0"]
points = generate_snowflake().T

Fullpoints = np.zeros([points.shape[1], 3])

Fullpoints[:, 0] = points[0, :]  #+10*i
Fullpoints[:, 1] = points[1, :]
# Fullpoints[:,2] = 2*i

plot.set_data("flake" + str(1),
              Fullpoints,
              rad,
              c=[0.85, 0.85, 1],
              mat="ice",
              rnd=False,
              geom=Geometry(8))

# n = 100000                             # 1M points, better not try this with matplotlib
# xyz = 3 * (np.random.random((n, 3)) - 0.5)   # random 3D positions
# r = 0.02 * np.random.random(n) + 0.002       # random radii

# plot = TkOptiX()
# plot.set_data("my plot", xyz, r=r)
# plot.get_rt_size()
plot.show()