FUBAR uses the statistical technique "Kriging" to rescale images with an global geometric pattern, called the variogram.
The image can be infinitely rescaled: the estimates ('o' on the left figure) are calculated from five neighbouring samples of the source image ('+' on the left figure). The image is 'noisy' because each pixel is a realization of the estimated value. In other words, each pixel is a random value with a mean and a variance from the local distribution. By changing the variogram (press 'v') or the variance multiplier, it is possible to control that variance.
Clicking the left mouse button zooms in on the image and right-click zooms the image back out. Press SPACEBAR to accept the current realization as the 'source image' -this will reduce noise at small scales.
Katta is a scalable, failure tolerant, distributed, data storage for real time access.
Katta serves large, replicated, indices as shards to serve high loads and very large data sets. These indices can be of different type. Currently implementations are available for Lucene and Hadoop mapfiles.
* Makes serving large or high load indices easy
* Serves very large Lucene or Hadoop Mapfile indices as index shards on many servers
* Replicate shards on different servers for performance and fault-tolerance
* Supports pluggable network topologies
* Master fail-over
* Fast, lightweight, easy to integrate
* Plays well with Hadoop clusters
* Apache Version 2 License
Writing efficient user interfaces is the main maxim, here at Vimperator labs. We often follow the Vim way of doing things, but extend its principles when necessary.
Towards this end, we've created the liberator library for Mozilla based applications, to encapsulate as many of these generic principles as possible, and liberate developers from the tedium of reinventing the wheel.
This open source software project connects the world of java with TWAIN.TWAIN is an application programming interface standard used to access scanners & digital cameras ... .
This package was developed to scan an image in order to turn it into an *.sff file and then fax it.
How does it work ? What happens ?
1. On loading: jtwain.java loads it's C++ counter part, the library jtwain.dll.
2. jtwain.dll will load "TWAIN_32.DLL" and get a function pointer to the DSM (Data Source Manager) entry point (twain state 2).
3. If loading was successful jtwain.java creates a new thread that calls nstart in jtwain.cpp.
4. Due to the fact that twain is signalling events through the OS-dependent event queues, we need to set up an application window including it's wndProc callback function.
5. After that ninitLib will open the DSM (twain state 3). Now the DSM is ready to handle device specific requests.
6. The native thread is then entering the event loop and calling jtwain.cbhandleGetMessage whenever it receives an event.
7. The twain entry function must be called from within the native thread. In order to do that a command can be initiated from arbitrary java threads by calling ntrigger. This will cause the native thread to call jtwain.cbexecute.
Two commands can be triggered:
1. Select: The DSM will pop up a select dialog and the user can select a data source.
2. Acquire: The data source will pop up a user dialog that allows the user to set various settings and then either scan or cancel the request. Once an image has been acquired by the twain data source as a DIB (Device Independent Bitmap) a BufferedImage object will be created and the DIB data copied to this BufferedImage. The jtwain object informs the ScannerListeners of the new image.
OmegaT is a free translation memory application written in Java. It is a tool intended for professional translators. It does not translate for you! (Software that does this is called "machine translation", and you will have to look elsewhere for it.) OmegaT has the following features:
* Fuzzy matching
* Match propagation
* Simultaneous processing of multiple-file projects
* Simultaneous use of multiple translation memories
* External glossaries
* Document file formats include:
XHTML and HTML
Microsoft Office 2007 XML
OpenOffice.org/StarOffice
XLIFF (Okapi)
MediaWiki (Wikipedia)
Plain text
* Unicode (UTF-8) support: can be used with non-Latin alphabets
* Support for right-to-left languages
* Compatible with other translation memory applications (TMX)
The goal of this project is to provide a small and cohesive set of powerful UI components that allow creating modern applications that provide visual functionality similar to or superseding that of Vista Explorer and Office 2007. The components provide consistent visuals under the existing core and third-party look-and-feels, respect the DPI settings of the user desktop and follow the core Swing guidelines in the external APIs and the internal implementation details.The component suite includes:
* Layer for defining and using resizable icons
* Command button component
* Command button panel component
* File viewer panel component
* Breadcrumb bar component
* Ribbon component
The project is licensed under BSD license and requires JDK 6.0
xmonad is a tiling window manager for X. Windows are arranged automatically to tile the screen without gaps or overlap, maximising screen use. Window manager features are accessible from the keyboard: a mouse is optional. xmonad is extensible in Haskell, allowing for powerful customisation. Custom layout algorithms, key bindings and other extensions may be written by the user in config files. Layouts are applied dynamically, and different layouts may be used on each workspace. Xinerama is fully supported, allowing windows to be tiled on several physical screens.
OpenSwing is an open-source suite of advanced graphics components based on Swing toolkit: these components are more sophisticated of those provided with Swing and can be manipolated directly inside the UI designer of the IDE.
It is also a framework that provides data binding mechanism between components and data model, based on the MVC paradigm. Data model is based on Java Beans (POJOs) and it is supported in all OpenSwing components, such as Grid control or components container.
Aperture is a Java framework for extracting and querying full-text content and metadata from various information systems (e.g. file systems, web sites, mail boxes) and the file formats (e.g. documents, images) occurring in these systems.
The Okapi Framework is a set of interface specifications, format definitions, components and applications that provides an environment to build interoperable tools for the different steps of the translation and localization process.
The goal of the Okapi Framework is to allow tools developers and localizers to build new localization processes or enhance existing ones to best meet their needs, while preserving a level of compatibility and interoperability. It also provides them with a way to share (and re-use) components across different solutions. The project uses and promotes open standards, where they exist. For the aspects where open standards are not defined yet, the framework offers its own. The ultimate goal is to adopt the industry standards when they are defined and useable.