• Good news, Bio Image Operation is now available as Open Source on GitHub

    https://github.com/folterj/BioImageOperation

     

  •  

    feature video

    Click here for the feature video

     

     

  • ant64

    The latest release of Bio Image Operation (BIO) is available here.

    BIO is only realsed as 64 bit, requiring a 64 bit version of Windows.

    Download BIO version 1.4.341.7

    Download BIO script instructions

     

    Version 1.4.341.7:

    - Added GPL license information

     

    Version 1.4.341.6:

    - Further improved automatically finding optimal tracking parameters

    - Added 'Check for updates' functionality

    - Minor bug fixes

     

    Version 1.4.341.5:

    - Significantly improved automatically finding optimal tracking parameters

    - Draw logarithmic color legend based on input parameters

    - Many improvements and bug fixes and updates to the help/manual

     

    Version 1.4.341.4:

    - Implemented directly writing to video file using H264 encoding

     

    Version 1.4.341.3:

    - Significant improvement in overall performance

     

    Version 1.4.341.2 (OpenCV 3.4.1):

    - Implemented all track draw functions including many options

    - Improved script argument checking and help

    - Uses OpenCV 3.4.1

     

    Version 1.4.34.1 (OpenCV 3.4) - This is a major rewrite from C#/Emgu to C++/OpenCV. These are the key points:

    - Using OpenCV directly - with full library support and using the latest version

    - Real-time processing of HD video source (on standard consumer hardware) due to significant performance improvements

    - Direct memory management with superior memory footprint

    - Improved error handling and argument checking

    - Built-in dynamically-generated script help

    - Improved cluster detection: using connected components for accurate cluster sizes

    - Very efficient custom image display, for minimal impact on main image processing loop

    - Improved installer with pre-requisites detection and download (using WiX)

    - Re-branded artwork

     

  • The ability to remember and associate concepts can be artificially emulated using Associative Neural Networks (ASNN). (See also autoassociative memory.) Applying ASNN reseach, we can see if it's possible to capture and generalise large amounts of information in an effective way. A neural network consists of nodes called neurons, and connections between these called synapses.

    A simple learning set is used to both construct and train the network. Note that training only takes a single pass to obtain synapse weights. Based on Active Associative Neural Graphs (ANAKG), I produced a customised implemented in C#, which more closely emulates the spiking neuron model, and aims at scalability. After training, a query can be entered by activating neurons in the network, resulting in a response which provides generalised information in relation to the input terms.

    To provide insight into the model and its workings, dynamic visualisation was added. This shows how the network is trained, and how the neurons and synapses in turn are activated. Key stages neurons go through as they are activated (with corresponding colours): activation (red), absolute refraction (blue), relative refraction (green).

    Taking DeepMind's mission statement as example, we train the model which forms the network and determines synaptic weights and efficiencies. Note stopwords are removed. Next we apply the simple query: "DeepMind". From the 123 word input (70 without stopwords), the model produces the folowing 17 word serialised output:

    "[deepmind] world leader artificial intelligence research application multiplier most positive impact human important ingenuity widely beneficial scientific advances"

    From the resulting output we can see the model gives a generalised summary in the context of both the input data and our search query.

    To be continued...

  • AI survival simulation

    This is an AI simulating simplified life & survival, inspired by Tierra. I wanted to not only reproduce this experiment, but take it a step further and observe other behaviour resulting from this. To do this I also made the programming more friendly and intuitive. Additionally, I separated out what is possible for entities to do, and things governed by laws or reason such as preservation of mass and energy.

    Instead of common models that are trained with fixed data sets, this is a competitive in situ evolutionary system. The simulation starts with a single entity, programmed with a basic set of instructions in the form of Condition -> Action. Besides entities there are resources that can be absorbed / consumed. These conditions / actions are stored in the entity, so each hold it's own flexible set of instructions. Additionally each entity has mass, energy and a unique identifier. It also has a version number corresponding to an instruction set. This is the standard instructions set:

     

    Conditions Action
    Energy:Low Unit:Entity Version:Different Move
    Energy:High Unit:Entity Version:Different Engage
    Unit:Resource     Engage
    Unit:Entity Version:Same Incomplete Program
    MassEnergy:Clone Unit:None   Clone
    Unit:None     Move

     

    The first action is it's highest priority, as only one action is performed - meaning it's a bit like an If / Else flow. A few key actions: if a resource is encountered, engage it (which means it will absorb it), and if enough mass and energy is available, clone and generate a 'child'. This initial set contains 19 instructions, stored sequentially in the entity.

    The environment is a one dimensional 'world' where the entity can move in. A simple representation is to loop the dimension into a circle as to best use the screen, at the same time limiting the 'world' to effectively loop around. Entities are visualised by a core with a unique ID number (intensity representing the amount of instruction completeness), a blue circle representing mass, and an outer red circle for the amount of energy. Resources look similar except it shows a blank centre. Entities can only engage with others while at the same location. The simulation starts with a single entity (ID '1', version 0), and an abundance of resources.

    tierrai1small

    When an entity is cloned, there is a chance of mutation. This means at random one condition/action will be removed or added. Note that cloning takes mass, energy and time equal to the number of instructions. So less instructions is beneficial. However, without essential instructions such as absorbing resources or cloning, the entity is heading for extinction.

    The game is about surviving in a competitive environment. So when an entity encounters another with a different version number, it will 'attack' it. First the energy will be expended, at the same time breaking down the energy 'barrier' of the other entity.

    Note that all this behaviour is dynamic, captured in the instructions of each entity. The centre of the screen shows how many entities of each version there are, indicating how 'well' a version with corresponding instructions is surviving.

    tierrai2small

    Selecting a version shows it's instruction set for further analysis.

    Although the experiment could be expanded more, it already reveals some interesting patterns. For example, it showed this mutation was out-surviving the standard instructions:

     

    Conditions Action
    Unit:Resource     Engage
    Unit:Entity Version:Same Incomplete Program
    MassEnergy:Clone Unit:None   Clone
    Unit:None     Move

     

    What's of particular interest about this, is that this entity does not engage with other entities, and would try to avoid - but at the same time lose in a sustained encounter. But because it's significantly smaller (only 11 instructions), it multiplies easier, and overall effectively survives better.

    Download Tierrai here

  • Flexible Script-based Image Operation

    Bio Image Operation or 'BIO', is a next generation Image processing tool focussing on biological applications, balancing ease of use with desired flexibility required for research.

    This tool has been developed in collaboration with biologists, using extensive captured images.

    The solution balancing both the need for research purposes and flexibility required for this, and desired ease of use is realised in a script based user interface.

    The tool uses the widely used OpenCV for many of it's image operations, with an efficient tracking algorithm allowing real time processing (upto HD @ 50 fps).

     

    Automated tracking example: Tracking from public source: ants walking on concrete with varying lighting (video used from this public source):

    tracking detail

    (View full video here)

     

    User Interface

    bio

     

    Visualisation example

    Visualising tracks simply using image combination (Source material from Tom Wenseleers and colleagues - University of Leuven)

    combine short

     

     

  • Theory

    The key points on theory and applications of procedural generation is described in the series Procedural Generation parts 1 to 3, where we looked at a number of elements that could describe our virtual world. In this section we look at a practical implementation, combining all the different elements.

    Implementation

    As application I chose a scenario based on the 3 part article, to generate a artificial 'world' with a varied terrain, climate and biomes. As I was making the implementation while writing the previous articles, the implementation is consistent with the information in the articles.

    The tool of choice was Microsoft Visual Studio, C# .net using WPF. WPF actually comes with a 3D engine (using the WPF component 'ViewPort3D') which was surprisingly easy to use, and ideal for implementing the visualisation of this atificially generated world. Credit also goes to the WriteableBitmapEx extension, which extends the WPF bitmap with convenient access functionality.

    The resulting application is crude, but includes a number of illustrative components:

    - Selection of key parameters such as the master seed number

    - A bitmap representation of the generated map (where 1 pixel represents 1 square km in this case)

    - Numerical key statistics on terrain / biomes

    - A 3D view of the current location within the map including immidiate surrounding

    Download

    Download ProceduralWorldGenerator

    Links

    Microsoft Visual Studio

    WPF

    WriteableBitmapEx

  • Background
    Changes in daily habits can provide important information regarding the overall health status of an individual. This research aimed to determine how meaningful information may be extracted from limited sensor data and transformed to provide clear visualisation for the clinicians who must use and interact with the data and make judgments on the condition of patients. We ascertained that a number of insightful features related to habits and physical condition could be determined from usage and motion sensor data.

    Methods
    Our approach to the design of the visualisation follows User Centered Design, specifically, defining requirements, designing corresponding visualisations and finally evaluating results. This cycle was iterated three times.

    Results
    The User Centered Design method was successfully employed to converge to a design that met the main objective of this study. The resulting visualisations of relevant features that were extracted from the sensor data were considered highly effective and intuitive to the clinicians and were considered suitable for monitoring the behavior patterns of patients.

    Conclusions
    We observed important differences in the approach and attitude of the researchers and clinicians. Whereas the researchers would prefer to have as many features and information as possible in each visualisation, the clinicians would prefer clarity and simplicity, often each visualisation having only a single feature, with several visualisations per page. In addition, concepts considered intuitive to the researchers were not always to the clinicians.

    Enumeration of conceived visualisations

    Identifier

    Description
    1.1 24 hour usage line graph
    1.2 24 hour usage activity simple
    1.3 24 hour usage activity colors
    1.4 24 hour usage activity bars
    2.1 24 hour motion activity line graph
    2.2 24 hour motion activity window
    2.3 24 hour motion activity window graph
    2.4 24 hour motion events / hour
    2.5 24 hour motion events / hour differences
    3.1 Days usage occupancy times
    3.2 Days usage occupancy hours
    3.3 Days usage occupancy only hours
    3.4 Days usage non-occupancy hours
    3.5 Days usage occupancy hours stacked
    3.6 Days usage occupancy hours stacked areas
    4.1 Days usage # events
    4.2 Days usage # events / day parts
    5.1 Raw usage occupancy
    6.1 Days motion nocturnal inactivity times
    6.2 Days motion nocturnal inactivity hours
    7.1 Days motion # events
    7.2 Days motion # events / day parts
    8.1 Raw motion # events / hour
    8.2 Raw motion activity 15 minute window
    8.3 Raw motion activity 30 minute window

     

    Visualisations

    The double digit identifier is extended by a third digit, which identifies the cycle number in the development process, resulting in the format: ‘(group).(variation).(cycle)’.

    For each main visualisation type, the development of the different versions is shown.

    decision making1

    2.2

    decision making2a

    decision making2b

    decision making3

    5.1

    decision making5

    decision making7

    doi: 10.1186/s12911-014-0102-x

  • Terrain

    Continuing from part 2, a scalable fractal method is used to create terrain. All attributes generated is based on a specific seed for the current region.
    An example of terrain elevation (black / blue: low, green / yellow: high), and using a threshold to define land (green) / water (blue)

    landanim

     

    Humidity / Rainfall

    Continuing to a more advanced scenario, humidity / rainfall could be determined from obvious sources, any bodies of water. In this case, a streight forward approach is used, using a Gaussian function / filter.

    Humidity / rainfall map (blue: humid, yellow: dry)

    humidityanim

     

    Temperature

    Temperature can be generated by using a similar algorithm used for the terrain, and subsequently applying a Gaussian filter. As mentioned, all the attributes for this region are based on a single seed. This means that for each map or set of attributes, random generators are reset to the start seed. Generating this secondary map for temperature would result in a geography identical to the terrain map. This is resolved by offsetting the generation by 1 or more draws.

    for (loop = n)
    {
        random()
    }
    // proceed with random draws from terrain

    It was found that a single draw is enough so the resulted maps show no similarity with previous generated maps based on the same seed.

    Additionally, this map can be adjusted for water and elevation. Above water temperature is moderated, reducing very low or very high temperatures towards a baseline value. For land, the temperature is reduced by the elevation level.

    Temperature map (red: hot, blue: cold)

    temperatureanim

     

    We now have elevation, humidity and temperature. Using composite coloring, these can be combined into a single map. But first, lets look at defining biomes.

     

    Biome

    As final step, biome type can be defined. The biome type can be determined as function of temperature and rainfall.

    Biome temp precip

     

    In the composite map, the temperature is shown using the red / blue color channels as in the temperature map, and humidity / rainfall is indicated using the green color channel. Water is shown as plain blue.

    Using a mapped coloring scheme, the biome types can be visualised on the same map.

    Composite map / Biome map

    biomeanim

    Links

    Generating Random Fractal Terrain

    Projections / Biome generation

    Hero Extant: World Generator

    Wikipedia: Biome

  • In part 1 we looked at the method used for creating terrain. Midpoint Displacement is a fractal method which results in self-similarity implicitely making it scalable. Moreover the method can be scaled depending on the extent of the scope (e.g. 10 m vs 1 km vs 10 km), and number of iterations into smaller sub-divisions it is continued for (e.g. from 1 km to about 1m after 10 iterations). But imagine a large map of 1000 km, where we want to evaluate terrain upto a detail of 1 m, would take a lot of computing power, and significant storage. And this is only considering a single plane in 2 dimensions. So we can introduce partitioning. This is used in Minecraft, which uses three dimension segments of 16 x 16 (x 256) m.
    In this case we use a two dimensional plane, of about 1000 km square, made up of 1000 x 1000 segments each representing 1 km square. Looking back to part 1, where we create an array of random seeds. Instead of a simple array, we create a 2 dimensional array of segements including a seed. To make this aspect scalable as well, seeds are generated in a similar order using a simple iterative midpoint method. This pattern is shown below, starting with the segments marked 1, then 2, 3, until each segment has a seed allocated.

    step = size while step > 1
    {
        for y = 0:size:step
        {
            for x = 0:size:step
            {
                seed[y,x] = new seed
            }
        }
        size / 2
    }

    Segmentation pattern

    gridanim

    Segments are only evaluated on-demand. Each segement is initialised using its seed, generating a terrain map. In addition other characteristics are evaluated as we will see in part 3.

    Links

    Generating Random Fractal Terrain

  • The concept of procedural generation is creation based on rules and algorithms, instead of manual construction. A common application is to create scenarios like a landscapes, but in such a way that is repeatable and predictable within a controlled setting. Additionally this normally results in high consistency. Though widely used in games including recent ones such as Minecraft and Rust, there are many other useful applications such as simulation modelling.

    Ideally, the generation is a fractal method providing scalability. We will look at this in more detail in part 2.

    To produce a set of proporties and attributes in a reproducible yet variable way, the common Random (or Rnd) function can be used. This function does not actually provide real random numbers, but psuedo random numbers. The 'random' numbers are generated, effectively implementing procedural generation. Additionally these are normally based on a start seed. So we want to create a set of properties, such as for different locations, each based on a seed. Next we want all of those to be based on one single master seed.

    In simple pseudo code:

    int masterSeed = 12345678

    Random randomGenerator = new Random(masterSeed)

    int[] locationSeeds = new int[100]

    foreach (int locationSeed in locationSeeds)
    {
        locationSeed = randomGenerator.getNext()
    }

    As this example illustrates, changing the masterSeed will result in a different set of location specific seeds. Next, for each specific location, different properties can be generated, in a consistent way - if and when they are required:

    Random randomGenerator = new Random(locationSeed)

    foreach (Property property in properties)
    {
        property = randomGenerator.getNext()
    }

    The method used for creating fractal terrain is Midpoint Displacement, though it is worth mentioning Perlin noise is another popular method used for this. Midpoint Displacement in one dimension is simple (see images below), starting with two points (1), and a straight line connecting these (2), find the midpoint on the line (3) and displace the new point up or down with a particular magnitude(4). There are now 2 connecting straight lines, drawn over 3 points (5). The process continues iteratively, finding the next midpoint between previous points in turn, and displacing these with a decreasing magnitude. For two dimension, the diamond-square algorithm is applied.
    Midpoint Displacement illustration

    midpointanim

    Links

    Procedural Content Generation in Games

    Generating Random Fractal Terrain

    Fractal landscape

    Diamond-Square algorithm

    Perlin noise

  • Educative visualisation illustrating separation processes

    anim

    anim2

    The full HD videos available are here:

    vimeo.com/joostdefolter/albums

  • Facilitating insight into a simulation model using visualization and dynamic model previews

    interactivity

    time

    Model simplification, by replacing iterative steps with unitary predictive equations, can enable dynamic interaction with a complex simulation process. Model previews extend the techniques of dynamic querying and query previews into the context of ad hoc simulation model exploration. A case study is presented within the domain of counter-current chromatography. The relatively novel method of insight evaluation was applied, given the exploratory nature of the task. The evaluation data show that the trade-off in accuracy is far outweighed by benefits of dynamic interaction. The number of insights gained using the enhanced interactive version of the computer model was more than six times higher than the number of insights gained using the basic version of the model. There was also a trend for dynamic interaction to facilitate insights of greater domain importance.

    dx.doi.org:10.1016/j.jvlc.2012.08.001

  • Completely graphical interface

    ProMISE 2 introduces a new completely graphical user interface. A visual representation of the column (top of image) allows selection of visual elements which enables specific input parameters. When input parameters are changed the visual column representation adapts to these parameters, and predictive results are shown real time in graph and numerical forms (bottom of image).

    Free for non-commercial purposes (academic e-mail address required for free registration).

    Download latest version here

    Download manual

    (Previously also featured at theliquidphase.org)

  • Probabilistic Model for Immiscible Separations and Extractions (ProMISE)

    Chromatography models, liquid-liquid models and specifically Counter-Current Chromatography (CCC) models are usually either iterative, or provide a final solution for peak elution. This paper describes providing a better model by finding a more elemental solution. A completely new model has been developed based on simulating probabilistic units. This model has been labelled ProMISE: Probabilistic Model for Immiscible phase Separations and Extractions, and has been realised in the form of a computer application, interactively visualising the behaviour of the units in the CCC process. It does not use compartments or cells like in the Craig based models, nor is it based on diffusion theory. With this new model, all the CCC flow modes can be accurately predicted. The main advantage over the previously developed model, is that it does not require a somewhat arbitrary number of steps or theoretical plates, and instead uses an efficiency factor. Furthermore, since this model is not based on compartments or cells like the Craig model, and is therefore not limited to a compartment or cell nature, it allows for an even greater flexibility.

    doi:10.1016/j.chroma.2010.12.079

     

  • Universal Counter Current Chromatography modelling based on Counter Current Distribution

    There is clearly a need for a model which is versatile enough to take into account the numerous operating modes and pump out procedures that can be used with counter-current chromatography (CCC). This paper will describe a universal model for counter-current chromatography based on counter-current distribution. The model is validated with real separations from the literature and against established CCC partition theory. This universal model is proven to give good results for isocratic flow modes, as well as for cocurrent CCC and dual flow CCC, and will likely also give good results for other modes such as intermittent CCC.

    doi:10.1016/j.chroma.2008.11.088

  • Based on a classic game, this games features AI algorithms.

    Features:

    - modified A* path finding

    - uses XNA platform

     

    Modified A* pathfinding visualised

     

    Path updated with new objectives

    drdashanim

     

    drdashanim2
    Programming language: C# / Object Oriented / Design Patterns: MVC

    MS Visual Studio; XNA framework; CLR .NET

     

    Controls:

    - XBox 360 controller (USB)


    Alternative controls:

    - movement: [Game pad] / arrow keys

    - start: [Start] / S

    - demo: [B] / D

    Download Dr. Dash V1.1

    Download Microsoft XNA redistributable (required)

  • This science game was especially designed for a university organised public engagement event.
    In this game, you need to order the different coloured components coming out of a chromatography system, aiming for a high purity end result.

     

    Features:

    - PC and Android version

    - graphics completely scalable

    - accurate colour mixing

    Separation visualised by accurate colour mixing

     

    Installation instructions:

    - download zip file

    - unzip contents into a folder

    - run setup.exe to start installer


    Controls:

    - XBox 360 controller (USB)


    Alternative controls:

    - movement: arrow keys

    - start: S

    Windows:

    Download SepaRate V1.1

    Android:

    Direct download

    Download from Google Play

  • Based on one of the most classic games, this games features AI algorithms - see if you can beat the 'demo' mode!

    Features:

    - Uses weight map to calculate best / worst location

    visualisation of weight map (wrapped around screen edges)

     

    Installation instructions:

    - download zip file

    - unzip contents into a folder

    - run setup.exe to start installer

     

    Controls:

    - movement: arrow keys

    Download Dr. Pac V1.2