Recently Created Projects

Igor preview generator for OS X

tkessler — Wed, 24 Apr 2013 07:30:57 -0700

This project will automatically create a preview of a saved Igor experiment by compiling its available windows into a notebook and saving the notebook in a central location and keep track of them with a UUID that matches a generated UUID string stored in the experiment.

The script will list the pxp files in the specified folder (instead of the notebook previews), and when you select one it will access the UUID stored in the pxp and match it to the appropriate preview file (or display "No Preview Available" if a preview has not yet been generated).

Furthermore, if you double-click the file in the preview panel then Igor will open it (or if you hold the Option key while doing this then Igor will reveal that experiment file in the Finder).

In addition, I've included a hook to generate the UUID and a preview for each experiment when it is saved (and tucked the notebook generation into the background), so this will be done automatically for any newly saved experiments and users will only see Igor take a split second longer to save when they press Command-S.

Lastly, the File menu that shows the preview browser panel by default, but if you hold the Option key then the menu entry will switch to "Generate Preview," which will create a UUID (only if one does not currently exist) and corresponding preview notebook file for the current experiment. Holding the Option key will also reveal a "Check Previews" option in the File menu, that will scan the current preview files and list any for which the preview does not have an accurate record of the corresponding experiment file location, allowing you to remove or update them accordingly.

Unfortunately some of these modifications tap into the OS X BSD layer via Igor's "ExecuteScriptText" command to run "do shell script" and execute the CLI tools "uuidgen" and "open." If there are equivalents in Windows then this can be used for Windows machines as well, but as it is, because of these requirements it's limited to OS X.

Pardon any funky programming approaches, but it should work nicely (at least for OS X users). I'm currently running OS X 10.8, but I believe the uuidgen and open commands are present in all versions of OS X supported with Igor 6. I've only tested this in Igor 6.3, but I expect it will work in recent older versions as well.

This project is an adaptation of the Experiment Preview project by jtigor, which largely uses the code from that project but reworks it to centralize the previews and offer direct file opening support from the panel, which I have not found to be available in the Windows version of Igor.

Experiment Preview

jtigor — Sun, 14 Apr 2013 17:06:24 -0700

The aim of this project is to aid the Igor Pro user in selecting one among many saved experiments. The method is to create a formatted notebook containing currently visible graphs in an open experiment. The notebook is saved under the same name and directory as the experiment. Saved notebooks can be quickly viewed through a panel containing a simple method of selecting a disk path and displaying the names of notebooks residing in that path in a list box. Contents of the notebook are displayed in a notebook subwindow on that panel when the user clicks on a item in the listbox.

Based on this topic on IgorExchange -- OS X Quicklook plugin for pxp files?

Line Scan Analysis

jtrapani — Thu, 11 Apr 2013 07:42:21 -0700

A procedure for generating kinetic profiles from analysis of intensity values from confocal line scans.
Sequential line scans are imported into 2D waves from either TIFF or Zeiss LSM* files.

Analysis options include:

choice of statistical test run on line scan data
ability to set inter-line scan-interval
stat values output to data table
creation of a graph and curve fit options

Running "Line Scan Analysis" from the Macros menu creates a panel (see screenshot).

(* requires the LSMreader.pxp written by Stephen R Ikeda
download from Igor Exchange: http://www.igorexchange.com/project/LSMreader)

Igor Sequencer for Arduino

hartelna — Fri, 05 Apr 2013 09:14:08 -0700

Igor Sequencer controls an Arduino device to produce sequences of output pulses in a user-defined sequence. It provides low cost control of up to 12 outputs in two banks of 6 pins with sub-millisecond accuracy. Sequences are programmed through a GUI and they can be saved and loaded for quick recall.

You will need an Arduino Uno or Mega (it will probably work with other Arduino models as well). A sketch is provided which contains the code to install on the Arduino. A manual describing installation and operation is also available for download.

This software has been tested on Macintosh and Windows versions of Igor running Igor Pro 6.3.

Further information can be found by following the links towards the bottom of the following page:
https://swww2.le.ac.uk/Members/nh88/software

Progress Meter

jtigor — Thu, 04 Apr 2013 05:41:12 -0700

//*****************************************************************
// Function ProgressMeter routines
//*****************************************************************
// Routines to create, update and destroy a little progress meter. This uses
// igor drawing commands in a panel. Data is normalized to a 0 to 100 unit
// scale and meter is updated every 5 units (20 increments).
// Truncates name to 40 characters and ensures that name is igor legal. Always
// use return value (string) from ProgressMeterCreate as MeterName parameter
// for ProgressMeterUpdate and ProgressMeterDestroy.
// Checks ckbShowProgress to see if progress meters are to be displayed.
// Programmer can select meter type or let it be selected by options panel (with type 0)
// type 1: thermometer, type 2: digital (numeric), type 3: clock.
// Update Meter routine returns "100" if named meter doesn't exist.

syntax highlighting for gtksourceview for editors like gedit or meld

charly — Thu, 28 Mar 2013 03:27:53 -0700

This set of files allows you to get syntax highlighting in gedit (http://en.wikipedia.org/wiki/Gedit) or meld (http://en.wikipedia.org/wiki/Meld_%28software%29). These editors are crossplatform (windows, mac, linux) and open source.
This allows to compensate for some missing features of the native igor editor, namely:

autocompletion

line numbering

automated bracket completion

automatic indentation

bookmarks

code snippets

Line wraping when printing

case change

multiedit (allowing to do a whole column of setDimLabel at once for example)

and last but not least, side-by-side code comparison.

To install, download gedit (or meld for the side by side comparison feature), and replace the gap.lang in the language-specs folder of gtksourceview by the one provided here.
On mac, this file is inside the gedit app folder when you download gedit
On linux, this file should be in /usr/share/gtksourceview-2.0/language-specs/ (or gtksourceview-3.0 depending on the version of the system)
(the file is called gap.lang since at the time it was created, there was no obvious way to support a new language so the hack consisted of replacing an existing one).
The igor.xml file only serves to get the same colors as in the igor editor. It goes in the styles folder under the gtksourceview folder (you can also load it manually in the preferences menu).
Gedit should now open .ipf files with the proper highlighting. To use the functionalities described above, you will need to activate the corresponding plugins in the preferences. In linux, this requires the gedit-plugins package. On mac, they are part of the package.

It's now complete thansk to Adam Lights Geshi highlighting plugin.

Graphical User Interface Procedures/General Utilities for Igor Programmers

jamie — Thu, 07 Mar 2013 17:40:09 -0800

A collection of utilties for user interface widgets (TabControls, SetVariables, PopMenus, window sizing, etc.) plus some other general utilities for Igor programming.

Channel Rhodopsin Mapper

jamie — Thu, 07 Mar 2013 13:23:00 -0800

Channel Rhodopsin Mapper (ChRMapper) is a package written for Igor Pro 6.1 or higher for making photoactivation maps in motor cortex expressing channel rhodopsin (Ayling et al., Nat Methods. 2009 Mar;6(3):219-24; http://www.ncbi.nlm.nih.gov/pubmed/19219033).
ChRMapper requires:

Data acquisition board from National Instruments

NIDAQmx XOP (http://www.wavemetrics.com/products/nidaqtools/nidaqtools.htm)

Computer-controllable stage (usually serial port with VDT2).

Laser plus associated optics to focus it on the sample (see paper for details).

A way to record an evoked signal (e.g.,electromyograms, position sensors, accelerometers)

ChRMapper features:

Control of light stimulaton with either a TTL gating signal or an analog voltage that determines intensity.

Control of stimulation position via a motorzied stage, or galvo mounted mirrors.

Recording of analog signals syncronized with the laser stimulation./li>
An efficient and intuitive panel-driven user interface.

A suite of functions to analyze the data, e.g., make maps of evoked movements.

Unit Testing Framework

thomas_braun — Wed, 27 Feb 2013 03:27:13 -0800

This project aims at providing a complete set of tools for programmers for writing and maintaining unit tests.

Features:

Runs on Windows and MacOSX
Completely documented and with lots of examples
Includes more than ten test assertions coming in three versions
Allows for the arbitrary grouping of test cases
Easyly expandable and adaptable
Support for executing test suites from the command line

Planned features (open for collaboration):

Threadsafe test assertions
Machine readable (XML) log file format
Igor Pro help file documentation

Doxygen filter for procedure files

thomas_braun — Tue, 19 Feb 2013 10:31:26 -0800

The Igor Pro procedure file syntax is not supported by doxygen.
The easiest way to support it, is to write an input filter for doxygen.
This project here is a proof of concept implementation in AWK of an filter which translates procedure files into C-ish output.

Requires GNU AWK.

Supported Features

Functions, including parameter type resolution and call-by-reference recognition
Constants

Workflow

Comment procedure files using doxygen commands
Tweak doxygen config file and define
INPUT_FILTER = "gawk -f doxygen-filter-ipf.awk"

Execute doxygen

Missing features

Support for macros and operations
Igor help file generation

Tone Generator for Audio Output

jtrapani — Thu, 06 Dec 2012 09:37:23 -0800

This is a procedure file that creates a panel for controlling generation of an audio tone (played out of the computer speakers or headphone jack).
Users can define frequency, duration, and whether the tone is repeated (as well as the delay between consecutive tones).

Compiling the procedure places a menu item in the Macros.

HITRAN procedures for Igor

ikonen — Thu, 29 Nov 2012 13:04:59 -0800

Collection of functions and procedures for loading data from the HITRAN database and simulating optical transmission through the atmosphere as a function of temperature, pressure and gas composition as well as thermal emission.

For more information about the HITRAN database, and to access the data files, go to:
http://www.cfa.harvard.edu/hitran/

Note that the free database does not contain much information regarding atmospheric layers. This package includes data for just sea level atmospheric composition (from Wikipedia) and not a complete atmospheric model capable of calculating slant paths, although extending the calculations in this package to include multiple layers would not be particularly difficult, given adequate atmospheric data (pressure, temperature and composition as a function of altitude).

There is no automated package installer: You should place the two procedure files into the user procedures folder (or a place a shortcut there) and the help file into the "Igor Help Files" folder (if you want it to load everytime) and invoke the procedures by adding

#include "HITRAN"

to the procedure window in an experiment. (The second procedure file, LineBroadening.ipf, is #included in the HITRAN file and can be downloaded separately as a stand alone Igor Exchange Project). Open the help file for more detailed setup instructions.

The package also includes demo packed experiment file which can be run without any other downloads, although it only includes a small subset of the whole database.

Currently only line-by-line data is supported, but I plan to start incorporating other data that is available as well.
Requirements:
1. Access to the database (available for free and open to the public, they ask for your email and to fill out a questionnaire regarding intended usage)
2. Two files downloaded from the database:
http://www.cfa.harvard.edu/HITRAN/HITRAN2008/Global_Data/molparam.txt
http://www.cfa.harvard.edu/HITRAN/HITRAN2008/Global_Data/parsum.dat
-and-
3. At least one more file of line parameters (you can find the entire database in one file called HITRAN08.par or you can download files for individual molecules)
4. Installation of MultiPeakFit.xop. I think this is now enabled by default on a new Igor installation, but it didn't use to be. If you get an error flagging LorentzianFit or VoigtFit as unknown objects, then enable the XOP by creating a shortcut to the file

C:\Program Files (x86)\WaveMetrics\Igor Pro Folder\More Extensions\Curve Fitting\MutliPeakFit.xop

and placing it in

C:\users\username\Documents\WaveMetrics\Igor Pro 6 User Files\Igor Extensions

(or the comparable folders on MacOS or older Windows versions)

Line Broadening

ikonen — Wed, 28 Nov 2012 11:09:05 -0800

Procedure File containing functions (and wrapper procedures with Menu calls) for convolving waveform data with standard spectroscopic peak shapes (Gaussian, Lorentzian and Voigt) with x-scaling awareness and preservation of integral normalization.

Also supplies functions to convert X,Y line data to combined waveform data (think adding a lineshape function to a spectral simulation given just frequencies and intensities). This is a much faster way to add a single lineshape function to a large set of X,Y line data than a direct approach using a wave assignment statement and a peak function, although it is not as flexible as the latter, requiring a single characteristic width (and any other peak shape characteristics besides center position and intensity) for the whole set.

HDF5gateway

Pete.Jemian — Sun, 25 Nov 2012 21:00:09 -0800

HDF5gateway makes it easy to read a HDF5 file into an IgorPro folder, including group and dataset attributes, such as a NeXus data file, modify it, and then write it back out.

The goal was to make it easy to read a HDF5 file into an IgorPro folder, including group and dataset attributes, such as a NeXus data file, modify it, and then write it back out. This file provides functions to do just that.

ThreadSafeUtils XOP

thomas_braun — Fri, 16 Nov 2012 11:21:26 -0800

ThreadSafeUtils is an XOP adding two utility functions for threadsafe programming.

threadSafeWrapper(userFunction)

executes userFunction and returns its string if running in the main thread and an empty string otherwise. This converts the compile-time threadsafe check of Igor procedures into a runtime check.

Details

userFunction must be a function returning a string and accepting no parameters. Although allowed it does not make sense that userFunction is threadsafe, because in that case userFunction is also usable with runtime checks for thread safety.

Examples

// non threadsafe function, because GetRTStackInfo is not threadsafe Function/S userFunction() return GetRTStackInfo(3) End // Calling workerFunction from the main thread will execute userFunction as // expected. If called in a igor preemptive thread, treadSafeWrapper will // not execute userFunction, instead an empty string is returned. // Note also that workerFunction can be labelled as ThreadSafe although it // might call the non threadsafe function userFunction. ThreadSafe Function workerFunction() printf "running in main thread %d\r", runningInMainThread() printf "returns _%s_\r", threadSafeWrapper("userFunction") End Function thread() variable tgID = ThreadGroupCreate(4) ThreadStart tgID, 0, workerFunction() variable result = ThreadGroupWait(tgID, INF) result = ThreadGroupRelease(tgID) End

runningInMainThread()

returns 1 if the code is executed in the Igor main thread and zero otherwise.

Brownian Motion Simulator

jtrapani — Tue, 13 Nov 2012 12:24:43 -0800

A Procedure File (BM_Simulator.ipf) for simulating a random walk and modeling Brownian Motion. This procedure creates a series of displacements generated after a "particle" experiences a series of random molecular collisions. Each collision moves the particle a distance determined by its mean free path setting. After a defined number of collisions, the particle is at a new, random location and the distance between its starting location and final location is termed a "displacement". In the laboratory setting, this is equivalent to the displacement a particle undergoes in between two consecutive frames during imaging with a CCD camera. A series of these random displacements is then used to estimate Brownian Motion for a particle in 2-D space.

Compiling the procedure places a Menu item under Macros.

Tango for Igor Pro

nleclercq — Sun, 11 Nov 2012 01:52:30 -0800

TANGO is an object oriented distributed control system being actively developed as a collaborative effort between several synchrotron institutes. The object model in TANGO supports methods, attributes and properties. In TANGO all objects are representations of devices. The devices can run on the same computer or distributed over computers interconnected by a network. The network communication is based on CORBA & ZMQ. Communication can be synchronous, asynchronous or event driven. Configuration data is stored in a database. On the server side, programming support is provided for C++, Java and Python under both Linux & Windows. Clients can be written in all three languages as well as using several commercial products - including Igor Pro. For more information, visit our “pink” website at: http://www.tango-controls.org

About the Tango binding package…

The Igor Pro package for TANGO contains an XOP and several procedures (including a code generator and a tutorial). It provides the user with a generic access to any server running into the control system. Thanks to Igor’s built-in features and programming capability, it becomes straightforward to write fast and powerful TANGO clients.

Generalized Linear Model Fitting

RGerkin — Wed, 07 Nov 2012 12:56:48 -0800

This implements generalized linear models in a function glmfit. Support for unity-link (gaussian distribution), log-link (poisson distribution), and logit-link (binomial distribution), and tan-link (von mises distribution). General usage given in function TestGLMFit, with a log-link (poisson) example. It is best to just contact me directly for support.

DE - optimize with differential evolution

andyfaff — Thu, 01 Nov 2012 15:58:36 -0700

Differential Optimisation - use instead of optimize if that isn't finding the global minimum.
Minimise (or maximise) an energy function by varying independent variables using differential evolution.

Easy peasy to use and comes with an example of how it works.

Fluorophore excitation and emission spectra

jtrapani — Mon, 29 Oct 2012 09:31:46 -0700

The following Igor pxp file includes a panel for plotting the excitation and emission spectra of various fluorophores, including fluorescent chemicals (e.g., FM 1-43) or genetically encoded molecules (e.g., GFP). Includes the ability to overlay filter cube information (currently just FITC/EGFP and TRITC).

Spectra are from Chroma.