pyopencl 2024.2.2__cp310-cp310-win_amd64.whl → 2024.2.5__cp310-cp310-win_amd64.whl

pyopencl-2024.2.2.data/data/examples/gl_interop_demo.py

@@ -1,84 +0,0 @@
-from OpenGL.GL import *
-from OpenGL.GLUT import *
-from OpenGL.raw.GL.VERSION.GL_1_5 import glBufferData as rawGlBufferData
-
-import pyopencl as cl
-
-
-n_vertices = 10000
-
-src = """
-
-__kernel void generate_sin(__global float2* a)
-{
-    int id = get_global_id(0);
-    int n = get_global_size(0);
-    float r = (float)id / (float)n;
-    float x = r * 16.0f * 3.1415f;
-    a[id].x = r * 2.0f - 1.0f;
-    a[id].y = native_sin(x);
-}
-
-"""
-
-def initialize():
-    platform = cl.get_platforms()[0]
-
-    import sys
-
-    from pyopencl.tools import get_gl_sharing_context_properties
-    if sys.platform == "darwin":
-        ctx = cl.Context(properties=get_gl_sharing_context_properties(),
-                devices=[])
-    else:
-        # Some OSs prefer clCreateContextFromType, some prefer
-        # clCreateContext. Try both.
-        try:
-            ctx = cl.Context(properties=[
-                (cl.context_properties.PLATFORM, platform)]
-                + get_gl_sharing_context_properties())
-        except:
-            ctx = cl.Context(properties=[
-                (cl.context_properties.PLATFORM, platform)]
-                + get_gl_sharing_context_properties(),
-                devices = [platform.get_devices()[0]])
-
-    glClearColor(1, 1, 1, 1)
-    glColor(0, 0, 1)
-    vbo = glGenBuffers(1)
-    glBindBuffer(GL_ARRAY_BUFFER, vbo)
-    rawGlBufferData(GL_ARRAY_BUFFER, n_vertices * 2 * 4, None, GL_STATIC_DRAW)
-    glEnableClientState(GL_VERTEX_ARRAY)
-    glVertexPointer(2, GL_FLOAT, 0, None)
-    coords_dev = cl.GLBuffer(ctx, cl.mem_flags.READ_WRITE, int(vbo))
-    prog = cl.Program(ctx, src).build()
-    queue = cl.CommandQueue(ctx)
-    cl.enqueue_acquire_gl_objects(queue, [coords_dev])
-    prog.generate_sin(queue, (n_vertices,), None, coords_dev)
-    cl.enqueue_release_gl_objects(queue, [coords_dev])
-    queue.finish()
-    glFlush()
-
-def display():
-    glClear(GL_COLOR_BUFFER_BIT)
-    glDrawArrays(GL_LINE_STRIP, 0, n_vertices)
-    glFlush()
-
-def reshape(w, h):
-    glViewport(0, 0, w, h)
-    glMatrixMode(GL_PROJECTION)
-    glLoadIdentity()
-    glMatrixMode(GL_MODELVIEW)
-
-if __name__ == '__main__':
-    import sys
-    glutInit(sys.argv)
-    if len(sys.argv) > 1:
-        n_vertices = int(sys.argv[1])
-    glutInitWindowSize(800, 160)
-    glutInitWindowPosition(0, 0)
-    glutCreateWindow('OpenCL/OpenGL Interop Tutorial: Sin Generator')
-    glutDisplayFunc(display)
-    glutReshapeFunc(reshape)
-    initialize()
-    glutMainLoop()

pyopencl-2024.2.2.data/data/examples/gl_particle_animation.py

@@ -1,218 +0,0 @@
-# Visualization of particles with gravity
-# Source: http://enja.org/2010/08/27/adventures-in-opencl-part-2-particles-with-opengl/
-
-import sys
-
-import numpy as np
-from OpenGL import GL, GLU, GLUT
-from OpenGL.arrays import vbo
-from OpenGL.GL import (
-    GL_ARRAY_BUFFER, GL_BLEND, GL_COLOR_ARRAY, GL_COLOR_BUFFER_BIT,
-    GL_DEPTH_BUFFER_BIT, GL_DYNAMIC_DRAW, GL_FLOAT, GL_MODELVIEW,
-    GL_ONE_MINUS_SRC_ALPHA, GL_POINT_SMOOTH, GL_POINTS, GL_PROJECTION, GL_SRC_ALPHA,
-    GL_VERTEX_ARRAY)
-from OpenGL.GLUT import GLUT_DEPTH, GLUT_DOUBLE, GLUT_RGBA
-
-import pyopencl as cl
-from pyopencl.tools import get_gl_sharing_context_properties
-
-
-mf = cl.mem_flags
-
-width = 800
-height = 600
-num_particles = 100000
-time_step = 0.005
-mouse_down = False
-mouse_old = {"x": 0.0, "y": 0.0}
-rotate = {"x": 0.0, "y": 0.0, "z": 0.0}
-translate = {"x": 0.0, "y": 0.0, "z": 0.0}
-initial_translate = {"x": 0.0, "y": 0.0, "z": -2.5}
-
-
-def glut_window():
-    GLUT.glutInit(sys.argv)
-    GLUT.glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
-    GLUT.glutInitWindowSize(width, height)
-    GLUT.glutInitWindowPosition(0, 0)
-    window = GLUT.glutCreateWindow("Particle Simulation")
-
-    GLUT.glutDisplayFunc(on_display)  # Called by GLUT every frame
-    GLUT.glutKeyboardFunc(on_key)
-    GLUT.glutMouseFunc(on_click)
-    GLUT.glutMotionFunc(on_mouse_move)
-    GLUT.glutTimerFunc(10, on_timer, 10)  # Call draw every 30 ms
-
-    GL.glViewport(0, 0, width, height)
-    GL.glMatrixMode(GL_PROJECTION)
-    GL.glLoadIdentity()
-    GLU.gluPerspective(60.0, width / float(height), 0.1, 1000.0)
-
-    return window
-
-
-def initial_buffers(num_particles):
-    rng = np.random.default_rng()
-
-    np_position = np.empty((num_particles, 4), dtype=np.float32)
-    np_color = np.empty((num_particles, 4), dtype=np.float32)
-    np_velocity = np.empty((num_particles, 4), dtype=np.float32)
-
-    np_position[:, 0] = np.sin(
-        np.arange(0.0, num_particles) * 2.001 * np.pi / num_particles
-    )
-    np_position[:, 0] *= rng.integers(num_particles) / 3.0 + 0.2
-    np_position[:, 1] = np.cos(
-        np.arange(0.0, num_particles) * 2.001 * np.pi / num_particles
-    )
-    np_position[:, 1] *= rng.integers(num_particles) / 3.0 + 0.2
-    np_position[:, 2] = 0.0
-    np_position[:, 3] = 1.0
-
-    np_color[:, :] = [1.0, 1.0, 1.0, 1.0]  # White particles
-
-    np_velocity[:, 0] = np_position[:, 0] * 2.0
-    np_velocity[:, 1] = np_position[:, 1] * 2.0
-    np_velocity[:, 2] = 3.0
-    np_velocity[:, 3] = rng.integers(num_particles)
-
-    gl_position = vbo.VBO(
-        data=np_position, usage=GL_DYNAMIC_DRAW, target=GL_ARRAY_BUFFER
-    )
-    gl_position.bind()
-    gl_color = vbo.VBO(data=np_color, usage=GL_DYNAMIC_DRAW, target=GL_ARRAY_BUFFER)
-    gl_color.bind()
-
-    return (np_position, np_velocity, gl_position, gl_color)
-
-
-def on_timer(t):
-    GLUT.glutTimerFunc(t, on_timer, t)
-    GLUT.glutPostRedisplay()
-
-
-def on_key(*args):
-    if args[0] == "\033" or args[0] == "q":
-        sys.exit()
-
-
-def on_click(button, state, x, y):
-    mouse_old["x"] = x
-    mouse_old["y"] = y
-
-
-def on_mouse_move(x, y):
-    rotate["x"] += (y - mouse_old["y"]) * 0.2
-    rotate["y"] += (x - mouse_old["x"]) * 0.2
-
-    mouse_old["x"] = x
-    mouse_old["y"] = y
-
-
-def on_display():
-    """Render the particles"""
-    # Update or particle positions by calling the OpenCL kernel
-    cl.enqueue_acquire_gl_objects(queue, [cl_gl_position, cl_gl_color])
-    kernelargs = (
-        cl_gl_position,
-        cl_gl_color,
-        cl_velocity,
-        cl_start_position,
-        cl_start_velocity,
-        np.float32(time_step),
-    )
-    program.particle_fountain(queue, (num_particles,), None, *(kernelargs))
-    cl.enqueue_release_gl_objects(queue, [cl_gl_position, cl_gl_color])
-    queue.finish()
-    GL.glFlush()
-
-    GL.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
-    GL.glMatrixMode(GL_MODELVIEW)
-    GL.glLoadIdentity()
-
-    # Handle mouse transformations
-    GL.glTranslatef(initial_translate["x"], initial_translate["y"], initial_translate["z"])
-    GL.glRotatef(rotate["x"], 1, 0, 0)
-    GL.glRotatef(rotate["y"], 0, 1, 0)  # we switched around the axis so make this rotate_z
-    GL.glTranslatef(translate["x"], translate["y"], translate["z"])
-
-    # Render the particles
-    GL.glEnable(GL_POINT_SMOOTH)
-    GL.glPointSize(2)
-    GL.glEnable(GL_BLEND)
-    GL.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
-
-    # Set up the VBOs
-    gl_color.bind()
-    GL.glColorPointer(4, GL_FLOAT, 0, gl_color)
-    gl_position.bind()
-    GL.glVertexPointer(4, GL_FLOAT, 0, gl_position)
-    GL.glEnableClientState(GL_VERTEX_ARRAY)
-    GL.glEnableClientState(GL_COLOR_ARRAY)
-
-    # Draw the VBOs
-    GL.glDrawArrays(GL_POINTS, 0, num_particles)
-
-    GL.glDisableClientState(GL_COLOR_ARRAY)
-    GL.glDisableClientState(GL_VERTEX_ARRAY)
-
-    GL.glDisable(GL_BLEND)
-
-    GLUT.glutSwapBuffers()
-
-
-window = glut_window()
-
-(np_position, np_velocity, gl_position, gl_color) = initial_buffers(num_particles)
-
-platform = cl.get_platforms()[0]
-context = cl.Context(
-    properties=[(cl.context_properties.PLATFORM, platform)]
-    + get_gl_sharing_context_properties()
-)
-queue = cl.CommandQueue(context)
-
-cl_velocity = cl.Buffer(context, mf.COPY_HOST_PTR, hostbuf=np_velocity)
-cl_start_position = cl.Buffer(
-    context, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np_position
-)
-cl_start_velocity = cl.Buffer(
-    context, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np_velocity
-)
-
-cl_gl_position = cl.GLBuffer(context, mf.READ_WRITE, int(gl_position))
-cl_gl_color = cl.GLBuffer(context, mf.READ_WRITE, int(gl_color))
-
-kernel = """__kernel void particle_fountain(__global float4* position,
-                                            __global float4* color,
-                                            __global float4* velocity,
-                                            __global float4* start_position,
-                                            __global float4* start_velocity,
-                                            float time_step)
-{
-    unsigned int i = get_global_id(0);
-    float4 p = position[i];
-    float4 v = velocity[i];
-    float life = velocity[i].w;
-    life -= time_step;
-    if (life <= 0.f)
-    {
-        p = start_position[i];
-        v = start_velocity[i];
-        life = 1.0f;
-    }
-
-    v.z -= 9.8f*time_step;
-    p.x += v.x*time_step;
-    p.y += v.y*time_step;
-    p.z += v.z*time_step;
-    v.w = life;
-
-    position[i] = p;
-    velocity[i] = v;
-
-    color[i].w = life; /* Fade points as life decreases */
-}"""
-program = cl.Program(context, kernel).build()
-
-GLUT.glutMainLoop()

pyopencl-2024.2.2.data/data/examples/ipython-demo.ipynb

@@ -1,203 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cc7d0709",
-   "metadata": {
-    "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
-    }
-   },
-   "outputs": [],
-   "source": [
-    "from __future__ import division\n",
-    "import numpy as np\n",
-    "import pyopencl as cl\n",
-    "import pyopencl.array"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8ac8d7bb",
-   "metadata": {},
-   "source": [
-    "Load the PyOpenCL IPython extension:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "7023ca2f",
-   "metadata": {
-    "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
-    }
-   },
-   "outputs": [],
-   "source": [
-    "%load_ext pyopencl.ipython_ext"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9544b53c",
-   "metadata": {},
-   "source": [
-    "Create an OpenCL context and a command queue:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fac17999",
-   "metadata": {
-    "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
-    }
-   },
-   "outputs": [],
-   "source": [
-    "ctx = cl.create_some_context(interactive=True)\n",
-    "queue = cl.CommandQueue(ctx)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a29daf04",
-   "metadata": {},
-   "source": [
-    "-----\n",
-    "\n",
-    "Define an OpenCL kernel using the `%%cl_kernel` magic:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "65c7e6c9",
-   "metadata": {
-    "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
-    }
-   },
-   "outputs": [],
-   "source": [
-    "%%cl_kernel -o \"-cl-fast-relaxed-math\"\n",
-    "\n",
-    "__kernel void sum_vector(__global const float *a,\n",
-    "__global const float *b, __global float *c)\n",
-    "{\n",
-    "  int gid = get_global_id(0);\n",
-    "  c[gid] = a[gid] + b[gid];\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cfb57357",
-   "metadata": {},
-   "source": [
-    "This looks for `cl_ctx` or `ctx` in the user namespace to find a PyOpenCL context.\n",
-    "\n",
-    "Kernel names are automatically injected into the user namespace, so we can just use `sum_vector` from Python below.\n",
-    "\n",
-    "Now create some data to work on:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1d80ff38",
-   "metadata": {
-    "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
-    }
-   },
-   "outputs": [],
-   "source": [
-    "n = 10000\n",
-    "\n",
-    "a = cl.array.empty(queue, n, dtype=np.float32)\n",
-    "a.fill(15)\n",
-    "\n",
-    "b_host = np.random.randn(n).astype(np.float32)\n",
-    "b = cl.array.to_device(queue, b_host)\n",
-    "\n",
-    "c = cl.array.empty_like(a)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "61fccb61",
-   "metadata": {},
-   "source": [
-    "Run the kernel:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2ba991b3",
-   "metadata": {
-    "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
-    }
-   },
-   "outputs": [],
-   "source": [
-    "sum_vector(queue, (n,), None, a.data, b.data, c.data)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "11a55b38",
-   "metadata": {},
-   "source": [
-    "Check the result using `numpy` operations:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ee3560c1",
-   "metadata": {
-    "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
-    }
-   },
-   "outputs": [],
-   "source": [
-    "assert (c.get() == b_host + 15).all()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pyopencl-2024.2.2.data/data/examples/median-filter.py

@@ -1,99 +0,0 @@
-import numpy as np
-from imageio import imread, imsave
-
-import pyopencl as cl
-
-
-# Read in image
-img = imread("noisyImage.jpg").astype(np.float32)
-print(img.shape)
-
-img = np.mean(img, axis=2)
-print(img.shape)
-
-ctx = cl.create_some_context()
-queue = cl.CommandQueue(ctx)
-
-mf = cl.mem_flags
-
-# Kernel function
-src = """
-void sort(int *a, int *b, int *c) {
-   int swap;
-   if(*a > *b) {
-      swap = *a;
-      *a = *b;
-      *b = swap;
-   }
-   if(*a > *c) {
-      swap = *a;
-      *a = *c;
-      *c = swap;
-   }
-   if(*b > *c) {
-      swap = *b;
-      *b = *c;
-      *c = swap;
-   }
-}
-__kernel void medianFilter(
-    __global float *img, __global float *result, __global int *width, __global
-    int *height)
-{
-    int w = *width;
-    int h = *height;
-    int posx = get_global_id(1);
-    int posy = get_global_id(0);
-    int i = w*posy + posx;
-    // Keeping the edge pixels the same
-    if( posx == 0 || posy == 0 || posx == w-1 || posy == h-1 )
-    {
-        result[i] = img[i];
-    }
-    else
-    {
-        int pixel00, pixel01, pixel02, pixel10, pixel11, pixel12, pixel20,
-            pixel21, pixel22;
-        pixel00 = img[i - 1 - w];
-        pixel01 = img[i- w];
-        pixel02 = img[i + 1 - w];
-        pixel10 = img[i - 1];
-        pixel11 = img[i];
-        pixel12 = img[i + 1];
-        pixel20 = img[i - 1 + w];
-        pixel21 = img[i + w];
-        pixel22 = img[i + 1 + w];
-        //sort the rows
-        sort( &(pixel00), &(pixel01), &(pixel02) );
-        sort( &(pixel10), &(pixel11), &(pixel12) );
-        sort( &(pixel20), &(pixel21), &(pixel22) );
-        //sort the columns
-        sort( &(pixel00), &(pixel10), &(pixel20) );
-        sort( &(pixel01), &(pixel11), &(pixel21) );
-        sort( &(pixel02), &(pixel12), &(pixel22) );
-        //sort the diagonal
-        sort( &(pixel00), &(pixel11), &(pixel22) );
-        // median is the the middle value of the diagonal
-        result[i] = pixel11;
-    }
-}
-"""
-
-# Kernel function instantiation
-prg = cl.Program(ctx, src).build()
-# Allocate memory for variables on the device
-img_g = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=img)
-result_g = cl.Buffer(ctx, mf.WRITE_ONLY, img.nbytes)
-width_g = cl.Buffer(
-    ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np.int32(img.shape[1])
-)
-height_g = cl.Buffer(
-    ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np.int32(img.shape[0])
-)
-# Call Kernel. Automatically takes care of block/grid distribution
-prg.medianFilter(queue, img.shape, None, img_g, result_g, width_g, height_g)
-result = np.empty_like(img)
-cl.enqueue_copy(queue, result, result_g)
-
-# Show the blurred image
-imsave("medianFilter-OpenCL.jpg", result, mode="RGB")