You ran the object detection image viewer sample that came with your stereo depth camera, object_detection_image_viewer.py, and the native desktop viewer opens the camera without a complaint, but the Python script dies on the first call that touches a window: OpenGL.error.NullFunctionError: Attempt to call an undefined function glutInit, check for bool(glutInit) before calling. The camera is not at fault, and neither is the GPU. PyOpenGL imported; the GLUT entry point behind glutInit never bound to a real library. This guide ranks the three causes by how often each one turns up, gives the one-line test that separates them, the commands that fix each on Windows, and a worked case on Python 3.6.8 that came down to a single missing DLL.
What the error text is telling you
PyOpenGL is a thin wrapper over C libraries. When you import OpenGL.GLUT, the package builds a callable for glutInit that is a pointer into a runtime it must locate at run time: freeglut.dll on Windows, with the old glut32.dll as the fallback. When no loadable library supplies the entry point, the pointer stays null and the wrapper raises NullFunctionError, naming the function it could not bind.
Two consequences follow. A clean import of OpenGL proves nothing about GLUT, because the GL and GLUT bindings sit over separate binaries. And the hint inside the message — check bool(glutInit) before calling — is a diagnostic, not a repair: guarding the call converts a crash into a skipped call, and a viewer with no window inspects nothing. freeglut.dll is a drop-in replacement for glut32.dll that carries extra entry points, so hunting for the original 1990s GLUT is wasted effort.
Cause 1: the install went into a different interpreter
The most frequent case: several Pythons on one machine, or the sample launched from an environment you never installed into. The bare pip on PATH can serve a different installation from the one running the script, so the install reports success and the sample still sees nothing. The symptom pattern is the clue: the native viewer works while only the Python path fails, because the two run against different environments.
Test it in the console you launch the sample from:
import OpenGL
from OpenGL import GLUT
If either import raises, the packages never reached this interpreter. Install through the interpreter itself:
python3 -m pip install PyOpenGL PyOpenGL_accelerate
When an older, partial install shadows the fresh one, overwrite it:
python3 -m pip install --ignore-installed PyOpenGL PyOpenGL_accelerate
The -m form is the whole point: it binds the install to the interpreter you just invoked. The same fault class hits camera SDKs from the other side — GenICam Python package not found: match your interpreter traces the interpreter hunt, and script finds no device but the viewer works: fix duplicate SDK installs is the mirror image, where the native tool sees one install and the script another.
Cause 2: PyOpenGL is present, freeglut.dll is not
The pip package does not bundle a GLUT runtime for Windows. On a clean machine the import succeeds and glutInit still fails, because no freeglut.dll exists anywhere the loader searches. That is the default outcome of a plain install on Windows — expect it rather than suspecting your setup.
Test the binding directly:
from OpenGL import GLUT
print(bool(GLUT.glutInit))
False, with the imports working, means the runtime DLL never loaded. Take a freeglut build that matches your interpreter and copy freeglut.dll where the library search finds it: the Windows system folder, the folder holding python.exe, or any directory on PATH. The 64-bit DLL sits under bin\x64 in the distribution. Some camera makers host PyOpenGL wheels with the runtime already inside; installing one of those, matched to your Python version, resolves the error in a single step:
python3 -m pip install <name_of_your_whl_file>
Cause 3: the DLL and the interpreter disagree on bitness
A 32-bit freeglut.dll on the search path of 64-bit Python will not load, and the wrapper reports it as the same NullFunctionError rather than as an architecture complaint. This catches people who copy a DLL out of an old 32-bit project. Decide by interpreter: 64-bit Python, the overwhelming default, needs the x64 build; a deliberate 32-bit Python needs the 32-bit build. When the bool test stays False with a DLL visibly in place, bitness is the cause — swap the file and retest.
| What you see | Cause | Fix |
|---|---|---|
| Import of OpenGL raises in the sample's console | Wrong interpreter | Install with python3 -m pip install
|
Imports work, bool(glutInit) prints False, no DLL present |
Missing runtime | Copy in a matching freeglut.dll |
| Imports work, False, a DLL is present | Bitness mismatch | Replace with the build for your interpreter |
The fix, step by step
- Open the console you normally launch the sample from — the same environment, not a shortcut to another interpreter.
- Install both packages through that interpreter with
python3 -m pip install PyOpenGL PyOpenGL_accelerate, or install the wheel from your camera maker's page with the same command form. Add--ignore-installedwhen an old copy shadows the new one. - Run the binding test from cause 2.
Truemeans you are done; continue only onFalse. - Confirm the interpreter's bitness and copy the matching freeglut.dll —
bin\x64for 64-bit Python — into the system folder, beside python.exe, or onto PATH. - Close the console, open a new one, and rerun the test until it prints
True. - Launch
object_detection_image_viewer.py. The window opens on the call that used to crash.
Worked example: Python 3.6.8 on Windows 10
A field case with every number visible: Windows 10, CUDA 10.2, Python 3.6.8 in the base environment, PyOpenGL 3.1.5 and PyOpenGL_accelerate already installed. The native desktop viewer connected to the camera and rendered; only the Python sample raised NullFunctionError at glutInit.
The diagnosis took four moves:
- The package listing showed PyOpenGL 3.1.5 in the base environment, and the sample ran from that same base environment, with no virtual environment in between. Cause 1 eliminated.
-
from OpenGL import GLUTimported cleanly, so the wrapper was present in the running interpreter. -
print(bool(GLUT.glutInit))printedFalse— wrapper present, entry point unbound. Cause 2 confirmed, with nothing left to reinstall. - The interpreter was 64-bit, so the
bin\x64build of freeglut.dll was the right file. Once copied into the system folder, a new console printedTrueand the sample opened its window.
The decision this hands you: when the package is demonstrably inside the running interpreter and the bool test still prints False, skip every reinstall and go straight to the DLL. A fourth reinstall of PyOpenGL will not create a DLL that the wheel never contained.
When the window opens: the failures that come next
Clearing glutInit returns you to ordinary viewer problems, each with its own fix:
- The window opens but the depth image will not display — the classic 16-bit depth versus 8-bit color clash: depth image 16UC1 display: fix color conversion errors.
- OpenGL raises invalid-value errors once rendering starts — a GPU driver issue, not GLUT: OpenGL invalid value error in depth viewers: fix the GPU driver.
- Your code shares buffers between CUDA and OpenGL for speed, and the interop path has setup rules of its own: CUDA OpenGL interop for 3D camera image display.
- A stereo processing node refuses to start — check the GPU runtime libraries before the camera: stereo depth node won't start: verify GPU runtime libraries first.
- The camera itself goes missing on the next run — a USB open failure, separate from rendering: depth camera no matching device found: fix USB open failure.
If your sensor streams over GigE instead of USB, the next bottleneck is the link, not the viewer: our frame grabbers span PoE GigE through 10GigE cards for exactly that path.
Keep it from coming back
- Install with the
-mform, always:python3 -m pip install ...ties each package to the interpreter you invoked. - One environment per project. A virtual environment for the vision stack stops the base interpreter and the sample interpreter from drifting apart.
- Keep a matching freeglut.dll beside python.exe of that environment, so the fix belongs to the environment rather than to one machine's system folder.
- Record SDK, firmware and package versions as one set. When they drift, failures surface in confusing places — 3D camera header version mismatch: fix firmware and SDK alignment shows the same discipline on the C++ side.
The cameras whose samples hit this
The fault lives on the PC, but it arrives with the camera: every stereo, structured-light or ToF sensor whose SDK draws point clouds through a Python viewer hits it on a fresh Windows machine. The sensor streams depth; your interpreter draws it, so the fix is identical whichever camera you run. A laser galvanometer stereo camera such as the MV-DLS300P-04 streams depth like any other, and so do the depth and structured-light models below.
- Type
- Stereo / structured light
Depth and structured-light cameras in the same class include:
- Type
- Depth / ToF camera
- Type
- Stereo / structured light
Laser profilers and stereo 3D cameras
170 models · from $699.00Browse the range in the 3D camera finder, read more viewer fixes on the 3D vision topic page, and if the stack still fights you after the DLL lands, bring your package listing and the bool test output to the contact page — those two facts usually settle it in one reply.
Questions
Does installing PyOpenGL_accelerate alone fix the glutInit NullFunctionError?
No. PyOpenGL_accelerate is the optional C accelerator for array handling and contains no windowing runtime. The GLUT entry points need the PyOpenGL package plus a loadable freeglut.dll, so the error survives any number of accelerator reinstalls. Install both packages into the correct interpreter, then check the DLL, in that order.
Where exactly should freeglut.dll go so Python finds it?
Anywhere the Windows library search covers: the system folder, the folder holding python.exe, or a directory on PATH. The system-folder copy needs one elevated action but serves every interpreter on the machine; a copy beside python.exe keeps the fix scoped to that environment. Open a fresh console afterwards either way.
Can I keep Python 3.6, or does the sample need a newer Python?
Keep it if the SDK lists it as supported, because the error has nothing to do with the Python version. The failing case ran Python 3.6.8 and cleared the moment the 64-bit freeglut.dll landed. What must match is the wheel tag and the DLL bitness, not a newer interpreter.
Why does bool(glutInit) print False even though OpenGL imports?
The import only loads the Python wrapper. Each GLUT callable is a pointer the wrapper fills by finding an exported symbol in freeglut.dll at run time; when no loadable library supplies it, the pointer stays null and bool reports False. That is exactly the state the error message tells you to test for.
The native desktop viewer shows the camera fine, so is the hardware faulty?
No. The desktop viewer links its own rendering libraries and never touches your Python stack, so it proves the camera, cable and power are good. The fault sits between the interpreter and the missing GLUT runtime. Fix the packages and the DLL, then retest before touching cables or firmware.
Do I need administrator rights to apply this fix?
Only for one placement. Copying freeglut.dll into the system folder asks for elevation once; dropping it beside python.exe or into a PATH folder you own needs none, and pip can install to your user site without elevation. On a locked-down workstation the whole fix is doable as a normal user.


