Semantic search

Jump to: navigation, search
Query Additional data to display
(add one property name per line)

Format as:
Sorting
[Add sorting condition]
Other options
limit:
The maximum number of results to return
offset:
The offset of the first result
link:
Show values as links
sort:
Property to sort the query by
order: descending desc asc ascending rand random
Order of the query sort
headers:
Display the headers/property names
mainlabel:
The label to give to the main page name
intro:
The text to display before the query results, if there are any
outro:
The text to display after the query results, if there are any
searchlabel:
Text for continuing the search
default:
The text to display if there are no query results
sep:
The separator for values
valuesep:
The separator for values
template:
The name of a template with which to display the printouts
template arguments:
Sets how the named arguments are passed to the template
named args:
Name the arguments passed to the template
userparam:
A value passed into each template call, if a template is used
introtemplate:
The name of a template to display before the query results, if there are any
outrotemplate:
The name of a template to display after the query results, if there are any
import-annotation:
Additional annotated data are to be copied during the parsing of a subject
Search

Hide query Show embed code

The query [[Graphics::3d]] was answered by the SMWSQLStore3 in 0.0063 seconds.


Results 11 – 60    (Previous 50 | Next 50)   (20 | 50 | 100 | 250 | 500)   (JSON | CSV | RSS | RDF)


Blender
Blender is an integrated 3D suite for modelling, animation, rendering, post-production, interactive creation and playback (games). Blender has its own particular user interface, which is implemented entirely in OpenGL and designed with speed in mind. Python bindings are available for scripting; import/export features for popular file formats like 3D Studio and Wavefront Obj are implemented as scripts by the community. Stills, animations, models for games or other third party engines and interactive content in the form of a standalone binary and/or a web plug-in are common products of Blender use.
CGAL
The goal of the CGAL Project is to provide easy access to efficient and reliable geometric algorithms in the form of a C++ library. CGAL is used in various areas needing geometric computation, such as: computer graphics, scientific visualization, computer aided design and modeling, geographic information systems, molecular biology, medical imaging, robotics and motion planning, mesh generation, numerical methods...
CGAL offers data structures and algorithms like triangulations (2D constrained triangulations and Delaunay triangulations in 2D and 3D), Voronoi diagrams (for 2D and 3D points, 2D additively weighted Voronoi diagrams, and segment Voronoi diagrams), Boolean operations on polygons and polyhedra, arrangements of curves and their applications (2D and 3D envelopes, Minkowski sums) mesh generation (2D Delaunay mesh generation and 3D surface mesh generation, skin surfaces), geometry processing (surface mesh simplification, subdivision and parameterization, as well as estimation of local differential properties, and approximation of ridges and umbilics), alpha shapes, convex hull algorithms (in 2D, 3D and dD), operations on polygons (straight skeleton and offset polygon), search structures (kd trees for nearest neighbor search, and range and segment trees), interpolation (natural neighbor interpolation and placement of streamlines), shape analysis, fitting, and distances (smallest enclosing sphere of points or spheres, smallest enclosing ellipsoid of points, principal component analysis), and kinetic data structures. All these data structures and algorithms operate on geometric objects like points and segments, and perform geometric tests on them. These objects and predicates are regrouped in CGAL Kernels.
CGKit (Python Computer Graphics Kit)
The Python Computer Graphics Kit is a collection of Python modules that contain the basic types and functions to be able to create 3D computer graphics images (focusing on Pixar's RenderMan interface).
Castle Game Engine
Castle Game Engine is a cross-platform 3D and 2D game engine for Object Pascal (FPC and Lazarus). - It supports many formats for game assets, including X3D, VRML, Collada, Spine JSON, MD3 and others. - Many graphic effects are possible, including bump mapping, shadows, shaders, mirrors, screen effects. - Animation, collision detection, 3D sound and more features are available. - An extensible system of 3D objects can be used, with out-of-the-box levels, items, intelligent creatures and more. - The engine is portable -- for desktop, mobile, web plugin. The engine is also used to develop view3dscene - a full-featured X3D / VRML browser and a viewer for many other 3D and 2D game formats.
Cl-ana
cl-ana is a library of modular utilities for reasonably high performance data analysis & visualization using Common Lisp. (Reasonably means I have to be able to use it for analyzing particle accelerator data). The library is made of various sublibraries and is designed in a very bottom-up way so that if you don't care about some feature you don't have to load it. The functionality support so far are
  • Tabular data analysis: Read-write of large datasets stored in HDF5 files are supported, along with ntuple datasets, CSVs, and in-memory data tables. Users can add their own table types by defining 4 methods and extending the table CLOS type.
  • Histograms: Binned data analysis is supported with both contiguous and sparse histogram types; functional interface is provided via map (which allows reduce/fold) and filter.
  • Plotting: Uses gnuplot for plotting dataset samples, plain-old lisp functions, histograms, strings-as-formulae, and anything else the user wishes to add via methods on a couple of generics.
  • Fitting: Uses GSL for non-linear least squares fitting. Uses plain-old lisp functions as the fit functions and can fit against dataset samples, histograms, and whatever the user adds.
  • Generic mathematics: CL doesn't provide extendable math functions, so cl-ana provides these as well as a convenient mechanism (a single function) for using these functions instead of the non-extendable versions. Already included are error propogation and quantities (values with units, e.g. 5 meters) as well as a GNU Octave-style handling of sequences (e.g. (+ (1 2) (3 4)) --> (4 6)).
Coin
Coin is a platform-independent retained-mode 3D graphics library that uses scene-graph data structures to render real-time graphics+suitable for mostly all kinds of scientific and engineering visualization applications. It is fully compatible with Open Inventor 2.1. Coin is built on the OpenGL immediate-mode rendering library, adds abstractions for higher-level primitives, provides 3D interactivity, increases programmer convenience and productivity, and contains optimization features for fast +rendering that are transparent for the application programmer.
Compiz
Compiz is the result of the re-unification of the Beryl-project and the community around the Compiz Window Manager. It seeks to provide an easy and fun-to-use windowing environment, allowing use of the graphics hardware to provide impressive effects, amazing speed and unrivalled usefulness. The first Compiz Fusion developer release was Compiz Fusion 0.5.2 on August 13th 2007.
Compiz Plugins- Extra
This is the Extra plugin package for Compiz.
Compiz Plugins- Main
This is the Main plugin package for Compiz.
Cpsed
'Cpsed' is a OpenGL 3D scene editor. It lets you import .3ds model files and position, rotate and scale each of them. It features open, save, and delete functions. The 3ds loader also loads the textures in JPG/BMP/TGA format. Support for DFF Renderware is planned. The scene file save format is pure ascii with comma separated values.
DrQueue
Drqueue is a distributed rendering queue. It manages jobs on a renderfarm. It supports Maya, Blender, and Bmrt (Renderman) out of the box, and can support any other renderer or computing task that can be handled via scripting. The package has three tools: master, slave and drqman. The master acts as a server where tasks are stored and where computers running slaves report success or failure in executing tasks. The slaves run on every node of the renderfarm. They report load average; if it is below a set level, they are available for rendering and take the first task assigned by the master server. drqman is a GUI for controlling jobs and computers.
Drishti
Drishti stands for vision or insight in Sanskrit, an Indian language. Drishti has been developed keeping in mind the end-use : visualizing tomography data, electron-microscopy data, etc. Understanding the data set is important and conveying that understanding to the research community or a lay person is equally important. Drishti is aiming for both. The central idea about Drishti is that the scientists should be able to use it for exploring volumetric datasets as well as use it in presentations.
EMAN
EMAN is a scientific image processing suite designed mainly to perform single-particle reconstructions of individual molecules. In this method, a transmission electron microscope is used to collect images of thousands of individual molecules. A complex series of algorithms then turns the individual 2D images into a high-resolution 3D structure of the molecule. The core of EMAN is a C++ based scientific image processing library.
Emerald- Compiz Theme Manager
Emerald controls the appearance of your window borders in Compiz. It allows you to install, edit and switch between various themes.
Equalizer
Equalizer is a framework for the development and deployment of parallel OpenGL applications. An Equalizer application can run unmodified on any visualization system, from a singlepipe workstation to large scale graphics clusters and multi-GPU workstations. Equalizer is built upon a scalable OpenGL-based programming interface solving problems that are common to any multipipe application. The API is minimally invasive, making application porting as easy as possible while delivering maximum performance.
Experimental Robotics Framework
The Experimental Robotics Framework is a framework for developing composable applications. The idea is to develop software components that interact with others previously developed in other applications and other components developed by other researchers. It is not a new concept in the field, it is very similar to IBM eclipse but in this case for 3d applications and based on C++ instead of Java.
Flames
"flam3' renders fractal flames as described on http://flam3.com. It is an advanced version of the Gimp plug-in. The package includes flam3-animate, which makes animations; flam3-render, which makes still images; and flam3-genome, which creates and manipulates genomes (parameter sets).
FreeCAD
FreeCAD is an CAx RAD based on OpenCasCade, Qt and Python. It features some key concepts like Macro recording, Workbenches, ability to run as a server and dynamically loadable Application extensions and it is designed to be platform independent.
FreeWRLDI
This is a candidate for deletion: Links broken. No links to page. Email to maintainer broken. Poppy-one (talk) 02:32, 31 July 2018 (EDT) FreeWRLDI (FreeWRLduneInputDevice), together with FreeWRL, lets you "hover" through 3D data in the Web with 4 degree of freedom input devices. It is based on FreeWRL's "/tmp/inpdev" extern sensor input interface and white_dune's input device mechanism.
GTO
The GTO format's primary usage is storage of static geometric data. The types of data you might find in a GTO file are things like polygonal meshes, various types of subdivision surfaces, NURBS or UBS surfaces, coordinate systems, hierarchies of objects, material bindings, and even images. "GTO' is used at Tweak Films to streamline the modeling, animation, rendering, and 3-D paint processes. It includes source code for a Maya plug-in, various command line tools, a Wavefront .obj parser, and a Python module for reading and writing GTO files. There is also an emacs mode gto-mode.el for editing GTO text files.
Geomview
Geomview is interactive geometry software which is particularly appropriate for mathematics research and education. It can display objects in hyperbolic and spherical space as well as Euclidean space. Geomview allows multiple independently controllable objects and cameras. It provides interactive control for motion, appearances (including lighting, shading, and materials), picking on an object, edge or vertex level, snapshots in SGI image file or Renderman RIB format. Adding or deleting objects is provided through direct mouse manipulation, control panels, and keyboard shortcuts. External programs can control certain aspects of viewing (such as continually loading changing geometry or controlling the motion of certain objects) while allowing interactive control of everything else. It can be used as a standalone viewer for static objects or as a display engine for other programs. It can display objects described in a variety of file formats. It comes with a wide selection of example objects, and you can create your own objects too.
Gleem Heckert gnu.tiny.png
Gleem (OpenGL Extremely-Easy-to-use Manipulators) is a library for Java and C++ offering a set of 3D widgets that support direct user interaction with a 3D scene. These widgets are used to translate along a line, translate in a plane, and do three-dimensional translation and rotation.
Glv - OpenGL viewer command line tool
A generic openGL viewer for the prompt. The goal of this project is to make 3d rendering as accessible as text is, with well-known command-line tools (like grep, sed, gnuplot, etc.). The viewer is useable with pipes, and defines a simple input format.
Gmsh
'Gmsh' is an automatic 3D finite element mesh generator with build-in CAD and post-processing facilities. Its design goal is to provide a simple meshing tool for academic test cases with parametric input and up to date visualization capabilities. It can respect a characteristic length field for the generation of adapted meshes on lines, surfaces and volumes, and mix these meshes with simple structured grids. Gmsh is built around four modules: geometry, mesh, solver and post-processing. The specification of any input to these modules is done either interactively using the graphical user interface or in ASCII text files using Gmsh's own scripting language.
Gnu3dkit
GNU 3DKit is an object oriented graphics framework for creating 3D graphics applications in the Objective-C language. The last version (released in 2002) can no longer be downloaded. It has since been decommissioned and is no longer developed. 3DKit was officially part of the GNU project as an extension to GNUstep. Its main application was to render 3D graphics in real-time on commodity hardware, using a scene graph architecture. It was based on OpenGL graphics library to achieve this goal.
Gnubik Heckert gnu.tiny.png
GNUbik is an interactive, graphical, single player game. It renders an image of a Rubik cube and allows you to manipulate it and hopefully solve it. GNUbik supports cubes of any size; 3x3x3 is the default. It also has a guile interface by which you can create your own scripts to solve the cube.
Godot
Godot is a 2D and 3D game engine, featuring:
  • Use your eyes
    • Work inside a simple, yet flexible and feature rich editor, with tools popping up to aid you only when you need them.
  • Develop 2D games
    • Create complex 2D games with the fully dedicated 2D engine (no need for 3D over 2D), using pixel coordinates and a wide array of tools.
  • Develop 3D games
    • Create realistic looking 3D games with the dedicated 3D Engine, with full support for lights, shadows, occlusion, post processing, skeletal animation, etc.
  • Script
    • Add custom behaviors to any object by extending it with scripting, using the built-in editor with syntax highlighting and code completion.
  • Design
    • Create simple or complex user interfaces, or make your own custom tools to edit your game content.
  • Animate
    • Animate your games with full support for editing, blending, animation trees, realtime cutscenes, calling function, or animate just any property exported by any node.
  • Simulate
    • Add physics to your 2D and 3D scenes, through rigid and static bodies, characters, raycasts, vehicles and more.
  • Debug
    • Use the built-in debugger with breakpoints and stepping, or check the performance graphs for possible bottlenecks.
  • Deploy
    • One-click deploy to several platforms, such as GNU/Linux, OS X, Windows, Android, iOS, BB10 and HTML 5.
  • Extend
    • Extend the editor and your game by using plugins, which add extra functionality for both.
  • Work in a team
    • Develop projects in a team using any choice of VCS, as Godot integrates flawlessly with all of them.
Gphoton
Gphoton is a simple 3d modeller with integrated ray tracer. It lets you construct/manipulate/modify a 3d model while approximating the scene with OpenGL. It renders with either the software ray-tracer or OpenGL; screenshots can be saved to TIF. You move around in the scene interactively with keyboard/mouse combinations and/or dialog clicks. It's intended primarily for artistic use (as opposed, for example, to use as a 3D modeller for games). As a ray-tracer entirely implemented in software, the program is extremely slow compared to hardware 3d graphics. However, being software, it is extremely flexible and extensible, more hardware independent, and can produce images of outstanding quality and very high resolutions (ie ANSI-E size 300 dpi images).
Graphics3D
'Graphics3D' is a C++ library for game developers, researchers, and students. It is a base of robust and high performance code common to most 3D projects. It is not a standalone graphics or game engine--it is a set of pieces to jumpstart your own engine or graphics project. The library has two parts: G3D for pure math, and GLG3D for interacting with hardware acceleration via OpenGL. You can use G3D without GLG3D if you want to use another 3D API or don't like the OpenGL abstraction.
Guile-opengl Heckert gnu.tiny.png
Guile-OpenGL is a library providing access to the OpenGL graphics API from Guile.
JFreeChart
A free Java chart library. JFreeChart supports pie charts (2D and 3D), bar charts (horizontal and vertical, regular and stacked), line charts, scatter plots, time series charts, high-low-open-close charts, candlestick plots, Gantt charts, combined plots, thermometers, dials and more. JFreeChart can be used in applications, applets, servlets and JSP. JFreeChart's extensive feature set includes: - a consistent and well-documented API, supporting a wide range of chart types; - a flexible design that is easy to extend, and targets both server-side and client-side applications; - support for many output types, including Swing components, image files (including PNG and JPEG), and vector graphics file formats (including PDF, EPS and SVG); - JFreeChart is free software. It is distributed under the terms of the GNU Lesser General Public Licence (LGPL), which permits use in proprietary applications.
K-3D
K-3D is an advanced 3D modeling, animation, and rendering system that is extremely portable. It is designed from-the-ground-up to generate motion-picture-quality animation using RenderMan, the de facto industry standard for 3D graphics.
K3DSurf
K3DSurf is a program for visualizing and manipulating multidimensional surfaces by using Mathematical equations. It's also a "modeler" for POV-Ray in the area of parametric surfaces. It features 3D, 4D, 5D, and 6D HyperObjects visualization, full support for all functions (like the C language), support for mouse events in the drawing area, animation and morph effects, Povscript and mesh file generation, and support for VRML2 and OBJ files. More than 100 examples are provided.
KiCad
KiCad is electronic design automation (EDA) software made for designing schematics of electronic circuits and printed circuit boards (PCB). KiCad is developed by the KiCad Developers Team, and features an integrated environment with schematic capture, bill of materials list, PCB layout and much more. KiCad is cross-platform, written with WxWidgets and runs on FreeBSD, Linux, Microsoft Windows and Mac OS X. A lot of component libraries are available. Also migrating tools for components are available (from other EDA software tools). File formats are plain text and well documented, which is good for CVS or Subversion and to make automated component generation scripts. Multiple languages are supported, such as English, Portuguese, Spanish, Czech, Polish, French, German, and Russian. The 3D PCB viewer use 3D model from Wings3D CAD.
Lib3ds
Lib3ds is a free library for handling 3DS files. Its goal is to simplify the creation of 3DS import and export filters. It features support for little and big endian CPUs, modules for vector, quaternion, and matrix mathematics, simple data structures which are easy to manipulate, evaluation of all animation data, seamless integration with OpenGL, and the ability to load most 3DS chunks found in the material, camera, light, mesh, and keyframer sections.
LibL3D
L3D is a 3D library for developing OpenGL applications under GNU/Linux. The library has a mail event loop with callbacks and Camera And Path Classes exist to produce cinematic camera movement. FPS entities are under construction.
LibQGLViewer
'libQGLViewer' is an C++ library which lets you quickly start the development of a new 3D application. It is designed for 3D developers, who can display and move around a 3D scene by simply providing the openGL orders that define their 3D geometry. The viewer is designed to be as general as possible and is not designed for a specific 3D application. It provides some useful classical functionalities such as a camera trackball, screenshot saving, mouse manipulated frames, stereo display, keyFrames and more. 'libQGLViewer' is not a 3D viewer that can be used directly to view 3D scenes in various formats; it is more likely to be the starting point for the coding of such a viewer.
LibTAP
'libTAP' (The Architectural Playground) is a prototyping system for virtual reality and augmented reality applications. It runs on a variety of platforms. RAP (rapid application prototyping) is done through the Lua interface, which mirrors the C++ namespace as closely as possible. libTAP has a small but distinctive feature set, focused on prototyping of realtime 3D simulations.
  • Also known as 'Tacitpixel'.
Lightfeather
Lightfeather is a 3D engine for GNU/Linux. It is designed to be easy to use but still take advantage of the features of modern graphics hardware.
Mandelbulber
Mandelbulber is an experimental application that helps to make rendering 3D Mandelbrot fractals much more accessible. A few of the supported 3D fractals: Mandelbulb, Mandelbox, BulbBox, JuliaBulb, Menger Sponge, Quaternion, Trigonometric, Hypercomplex, and Iterated Function Systems. All of these can be combined into infinite variations with the ability to hybridize different formulas together.
Maverik Heckert gnu.tiny.png
Maverik is a development toolkit that supports 3D virtual environments and interaction with those environments. It sits on top of a low-level rendering engine that uses OpenGL or Mesa, and provides mechanisms to render different kinds of objects, to manage environments and to provide support for 3D interaction. The system is open-ended in how its representation of different models. It uses call back functions, rather than importing and converting data to its own formats; this means it can be adapted relatively easily to widely differing application data structures without forcing particular representations on the implementor. For example, if you have a sim in which different parts of your model are varying dynamically but in ways that cannot be represented using the normal affine transformations (eg deformable objects), then Maverik lets you use the dynamically changing data directly to generate images. It also contains support for a variety of 3D input designs, and various kinds of displays (including stereo).
MeshLab
The MeshLab system is aimed to help the processing of the typical not-so-small unstructured 3D triangular models arising in 3D scanning; it provides a set of tools for editing, cleaning, healing, inspecting, rendering and converting this kind of meshes. It support many 3D formats and it is able to load and process large meshes composed by millions of triangles.
MisfitModel3D
'Misfit Model 3D' is an OpenGL-based 3D model editor. It supports multi-level undo, skeletal animations, simple texturing, scripting, command-line batch processing, and a plugin system for adding new model and image filters, and includes complete online help.
Moonlight3D
Moonlight3D is a modeller for 3-dimensional art. It supports Nurbs- and Bezier curve based modelling and many basic shapes (such as Box, Sphere, Cylinder, Plane, Cone and Torus) as well as many texture, material and light parameters, that can be rendered using the inbuilt raytracing-renderer. You can even create objects using Extrusion, Revolution or Skin-, Sweep-, Soft- and BiRail-Surfaces. You can import models using the DXF and 3DS standards, and export to RIB, DXF, VRML, Rayshade, and POV.
NetRadiant
NetRadiant is a map editor for BSP maps. It can create and edit maps for several games, including Xonotic and OpenArena.
Octave-interval
The interval package for real-valued interval arithmetic allows one to evaluate functions over subsets of their domain. All results are verified, because interval computations automatically keep track of any errors. These concepts can be used to handle uncertainties, estimate arithmetic errors and produce reliable results. Also it can be applied to computer-assisted proofs, constraint programming, and verified computing. The implementation is based on interval boundaries represented by binary64 numbers and is conforming to IEEE Std 1788-2015, IEEE standard for interval arithmetic.
OpenGLUT
OpenGLUT is a project to evolve the GLUT (OpenGL Utility Toolkit) C/C++ API. OpenGLUT uses the freeglut code base (from which it split in February 2004) as a foundation for extending, enhancing and refining the API.
OpenSceneGraph Editor
OpenSceneGraph Editor (OSGEdit) is used to compose complex scenes based on individual models using the OSG library. It is focused on making scenes for use in OSG-based programs.
OpenShot
OpenShot can take your videos, photos, and music files and help you create the film you have always dreamed of. Easily add sub-titles, transitions, and effects, and then export your film to many common formats.
OpenStudio
Comprehensive modeling software to analyze energy consumption (e.g., heating and air conditioning demand) in building and other structures. Developed by the Alliance for Sustainable Energy, LLC, operator and manager of the U.S. Dept. of Energy National Renewable Energy Laboratory. Support: https://unmethours.com/questions/


Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the page “GNU Free Documentation License”.

The copyright and license notices on this page only apply to the text on this page. Any software or copyright-licenses or other similar notices described in this text has its own copyright notice and license, which can usually be found in the distribution or license text itself.