CINXE.COM

<!DOCTYPE html> <html> <head> <title>Clojure Scripting</title> <meta charset="utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=3" /> <meta content="ImageJ Wiki" property="og:site_name"> <meta content="Clojure Scripting" property="og:title"> <meta content="article" property="og:type"> <meta content="The ImageJ wiki is a community-edited knowledge base on topics relating to ImageJ, a public domain program for processing and analyzing scientific images, and its ecosystem of derivatives and variants, including ImageJ2, Fiji, and others." property="og:description"> <meta content="https://imagej.github.io/scripting/clojure" property="og:url"> <meta content="https://imagej.github.io/media/icons/imagej2.png" property="og:image"> <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png"> <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png"> <link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png"> <link rel="manifest" href="/site.webmanifest"> <link rel="mask-icon" href="/safari-pinned-tab.svg" color="#5bbad5"> <meta name="msapplication-TileColor" content="#da532c"> <meta name="theme-color" content="#ffffff"> <link rel="stylesheet" href="/assets/css/lightbox.min.css" /> <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/instantsearch.css@7/themes/algolia-min.css"/> <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/dygraphs@2.1.0/dist/dygraph.min.js"></script> <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/dygraphs@2.1.0/dist/dygraph.min.css" /> <link rel="stylesheet" href="/assets/css/main.css" /> <link rel="stylesheet" href="/assets/css/layout.css"/> <link rel="stylesheet" href="/assets/css/includes.css" /> <link rel="stylesheet" href="/assets/css/timeline.css"/> <link rel="stylesheet" href="/assets/css/dock.css"/> <noscript><link rel="stylesheet" href="/assets/css/noscript.css" /></noscript> <link rel="stylesheet" href="/assets/css/page.css" /> </head> <body class="is-preload">  <section id="top-bar"> <a href="/"><img id="site-logo" src="/media/icons/imagej2.png"></a> <div id="search-panel"> <div id="search-box"></div> </div> </section>  <div class="page-info"> <a href="https://github.com/imagej/imagej.github.io/commits/main/_pages/scripting/clojure.md">Page history</a> <a href="https://github.com/imagej/imagej.github.io/edit/main/_pages/scripting/clojure.md">Edit this page</a> <a href="/editing">How do I edit this website?</a> <a href="https://imagej.net/imagej-wiki-static/Clojure_Scripting">Original MediaWiki page</a></div> <section id="left-column" class="sidebar dock">  <div class="menu dockable"> <div class="drag-handle"></div><h3>ImageJ Docs</h3> <ul> <li><a href="/downloads">Download</a></li> <li><details><summary>Learn</summary><ul> <li><details><summary><a href="/learn">ImageJ Basics</a></summary><ul> <li><a href="/tutorials">Tutorials</a></li> <li><a href="/learn/user-guides">User Guides</a></li> <li><a href="/learn/keyboard-shortcuts">Keyboard Shortcuts</a></li> <li><a href="/learn/tips-and-tricks">Tips and Tricks</a></li> <li><a href="/learn/troubleshooting">Troubleshooting</a></li> <li><a href="/learn/faq">Frequently Asked Questions</a></li> <li><details><summary><a href="/platforms">Supported Platforms</a></summary><ul> <li><a href="/platforms/windows">Windows</a></li> <li><a href="/platforms/macos">MacOS</a></li> <li><a href="/platforms/linux">Linux</a></li> <li><a href="/platforms/pi">Raspberry Pi</a></li> <li><a href="/platforms/android">Android</a></li> </ul></details></li>  <li><details><summary><a href="/formats">File Formats</a></summary><ul> <li><a href="/formats/bio-formats">Bio-Formats</a></li> <li><a href="/formats/video">Video formats</a></li> <li><a href="/formats/quicktime">QuickTime</a></li> <li><a href="/formats/tiff">TIFF</a></li> <li><a href="/formats/pdf">PDF</a></li> <li><a href="/formats/dicom">DICOM</a></li> <li><a href="/formats/lsm">Zeiss LSM</a></li> <li><a href="/formats/olympus">Olympus VSI</a></li> <li><a href="/formats/lurawave">Opera Flex</a></li> <li><a href="/formats/fib-sem">FIB-SEM</a></li> </ul></details></li>  </ul></details></li>  <li><details><summary><a href="/imaging">Scientific Imaging</a></summary><ul> <li><a href="/imaging/principles">Principles of Scientific Imaging</a></li> <li><a href="/imaging/annotating-images">Annotating Images</a></li> <li><a href="/imaging/colocalization-analysis">Colocalization</a></li> <li><a href="/imaging/color-image-processing">Color Image Processing</a></li> <li><a href="/imaging/deconvolution">Deconvolution</a></li> <li><a href="/imaging/image-intensity-processing">Image Intensity Processing</a></li> <li><a href="/imaging/particle-analysis">Particle Analysis</a></li> <li><a href="/imaging/registration">Registration</a></li> <li><a href="/imaging/segmentation">Segmentation</a></li> <li><a href="/imaging/stack-slice-manipulations">Stack-slice Manipulations</a></li> <li><a href="/imaging/t-functions">T-functions</a></li> <li><a href="/imaging/tracking">Tracking</a></li> <li><a href="/imaging/visualization">Visualization</a></li> <li><a href="/imaging/z-functions">Z-functions</a></li> </ul></details></li>  </ul></details></li>  <li><details open><summary><a href="/plugins">Extend</a></summary><ul> <li><a href="/list-of-extensions">List of Extensions</a></li> <li><details><summary><a href="/update-sites">Update Sites</a></summary><ul> <li><a href="/list-of-update-sites">List of Update Sites</a></li> <li><a href="/update-sites/following">Following an Update Site</a></li> <li><a href="/update-sites/setup">Creating an Update Site</a></li> <li><a href="/update-sites/tos">Terms of Service</a></li> <li><a href="/update-sites/automatic-uploads">Automatic Upload</a></li> <li><a href="/update-sites/core-uploads">Uploading to Core Sites</a></li> <li><a href="/update-sites/faq">Update Sites FAQ</a></li> <li><a href="/update-sites/stats">Statistics</a></li> </ul></details></li>  <li><details open><summary><a href="/scripting">Scripting</a></summary><ul> <li><a href="/scripting/basics">Scripting Basics</a></li> <li><a href="/scripting/script-editor">Script Editor</a></li> <li><a href="/scripting/parameters">Parameters</a></li> <li><a href="/scripting/user-input">User Input</a></li> <li><a href="/scripting/auto-imports">Auto Import</a></li> <li><a href="/scripting/templates">Templates</a></li> <li><a href="/scripting/batch">Batch Processing</a></li> <li><a href="/scripting/headless">Running Headlessly</a></li> <li><a href="/scripting/comparisons">Scripting Comparisons</a></li> <li><a href="/scripting/toolbox">Toolbox</a></li> <li><details open><summary>Languages</summary><ul> <li><a href="/scripting/beanshell">BeanShell Scripting</a></li> <li><a href="/scripting/groovy">Groovy Scripting</a></li> <li><a href="/scripting/macro">ImageJ Macro</a></li> <li><a href="/scripting/javascript">JavaScript</a></li> <li><a class="current-page">Lisp (Clojure)</a></li> <li><a href="/scripting/matlab">MATLAB</a></li> <li><a href="/scripting/jython">Python (Jython)</a></li> <li><a href="/scripting/python">Python (native)</a></li> <li><a href="/scripting/renjin">R (Renjin)</a></li> <li><a href="/scripting/jruby">Ruby (JRuby)</a></li> <li><a href="/scripting/scala">Scala Scripting</a></li> </ul></details></li>  </ul></details></li>  <li><details><summary><a href="/develop">Development</a></summary><ul> <li><a href="/develop/philosophy">Philosophy</a></li> <li><a href="/develop/architecture">Architecture</a></li> <li><a href="/develop/source">Source code</a></li> <li><a href="/develop/project-management">Project management</a></li> <li><a href="/develop/coding-style">Coding style</a></li> <li><a href="/develop/javadoc">Using Javadoc</a></li> <li><a href="/develop/debugging">Debugging</a></li> <li><a href="/develop/wish-list">Wish list</a></li> <li><details><summary>Tools</summary><ul> <li><a href="/develop/github">GitHub</a></li> <li><a href="/develop/maven">Maven</a></li> <li><a href="/develop/ci">CI/CD</a></li> <li><a href="/develop/dotfiles">Dotfiles</a></li> <li><details><summary><a href="/develop/ides">IDEs</a></summary><ul> <li><a href="/develop/eclipse">Eclipse</a></li> <li><a href="/develop/netbeans">NetBeans</a></li> <li><a href="/develop/intellij">IntelliJ IDEA</a></li> <li><a href="/develop/command-line">Command Line</a></li> </ul></details></li> </ul></details></li>  <li><details><summary>Guides</summary><ul> <li><a href="/develop/plugins">Writing plugins</a></li> <li><a href="/develop/improving-the-code">Contributing to a plugin</a></li> <li><a href="/develop/releasing">Development lifecycle</a></li> <li><a href="/develop/building-a-pom">Building a POM</a></li> <li><a href="/develop/debugging-exercises">Hands-on debugging</a></li> <li><a href="/develop/writing-ops">Adding new ops</a></li> <li><a href="/develop/formats">Adding new formats</a></li> <li><a href="/develop/native-libraries">Using native libraries</a></li> <li><a href="/develop/tips">Tips for developers</a></li> <li><a href="/develop/cpp-tips">Tips for C++ developers</a></li> <li><a href="/develop/ij1-plugins">ImageJ 1.x plugins</a></li> <li><a href="/develop/versioning">Versioning</a></li> <li><a href="/develop/logging">Logging</a></li> <li><a href="/develop/uber-jars">Uber-JARs</a></li> </ul></details></li>  <li><details><summary><a href="/develop/git">Git</a></summary><ul> <li><a href="/develop/git/eclipse">Git in Eclipse (EGit)</a></li> <li><a href="/develop/git/mini-howto">Git mini howto</a></li> <li><a href="/develop/git/workshop">Git workshop</a></li> <li><a href="/develop/git/conflicts">Git conflicts</a></li> <li><a href="/develop/git/topic-branches">Git topic branches</a></li> <li><a href="/develop/git/notes">Git notes</a></li> <li><a href="/develop/git/reflogs">Git reflogs</a></li> <li><a href="/develop/git/submodules">Git submodules</a></li> <li><a href="/develop/git/pinpoint-regressions">How to pinpoint regressions</a></li> <li><a href="/develop/git/publish-a-repository">How to publish a git repository</a></li> <li><a href="/develop/git/extract-a-subproject">How to extract a subproject</a></li> </ul></details></li>  </ul></details></li>  </ul></details></li>  <li><details><summary><a href="/contribute">Contribute</a></summary><ul> <li><a href="/contribute/citing">Citing</a></li> <li><a href="/people">Contributors</a></li> <li><a href="/orgs">Organizations</a></li> <li><a href="/contribute/governance">Governance</a></li> <li><a href="/contribute/funding">Funding</a></li> <li><a href="/contribute/fiji">Contributing to Fiji</a></li> <li><details><summary><a href="/licensing">Licensing</a></summary><ul> <li><details><summary><a href="/licensing/open-source">Open Source</a></summary><ul> <li><a href="/licensing/apache">Apache</a></li> <li><a href="/licensing/bsd">BSD</a></li> <li><a href="/licensing/epl">EPL</a></li> <li><a href="/licensing/gpl">GPL</a></li> <li><a href="/licensing/lgpl">LGPL</a></li> <li><a href="/licensing/mit">MIT</a></li> <li><a href="/licensing/public-domain">Public domain</a></li> <li><a href="/licensing/big">BIG</a></li> </ul></details></li>  <li><a href="/licensing/closed-source">Proprietary</a></li> </ul></details></li>  <li><details><summary><a href="/editing">Editing the Wiki</a></summary><ul> <li><a href="/editing/advanced">Advanced Editing</a></li> <li><a href="/editing/buttons">Buttons</a></li> <li><a href="/editing/citations">Citations</a></li> <li><a href="/editing/code">Source Code</a></li> <li><a href="/editing/debugging">Debugging</a></li> <li><a href="/editing/headers">Headers</a></li> <li><a href="/editing/icons">Icons</a></li> <li><a href="/editing/images">Images</a></li> <li><a href="/editing/keys">Keyboard Shortcuts</a></li> <li><a href="/editing/linking">Linking</a></li> <li><a href="/editing/math">Math Expressions</a></li> <li><a href="/editing/menu-paths">Menu Paths</a></li> <li><a href="/editing/navigation">Navigation</a></li> <li><a href="/editing/notices">Notices</a></li> <li><a href="/editing/people">People</a></li> <li><a href="/editing/pitfalls">Pitfalls</a></li> <li><a href="/editing/quizzes">Quizzes</a></li> <li><a href="/editing/statbox">Statbox</a></li> <li><a href="/editing/symbols">Symbols</a></li> <li><a href="/editing/tables">Tables</a></li> <li><a href="/editing/timelines">Timelines</a></li> <li><a href="/editing/tooltips">Tooltips</a></li> <li><a href="/editing/videos">Videos</a></li> <li><a href="/editing/whitespace">Whitespace</a></li> </ul></details></li>  </ul></details></li>  <li><details><summary><a href="/discuss">Discuss</a></summary><ul> <li><a href="/discuss/bugs">Reporting Issues</a></li> <li><a href="/discuss/mailing-lists">Mailing Lists</a></li> <li><a href="/discuss/chat">Chat</a></li> </ul></details></li>  <li><details><summary>Explore</summary><ul> <li><a href="/news">News</a></li> <li><details><summary><a href="/events">Events</a></summary><ul> <li><a href="/events/presentations">Presentations</a></li> <li><a href="/events/conferences">Conferences</a></li> <li><a href="/events/hackathons">Hackathons</a></li> <li><a href="/events">More...</a></li> </ul></details></li>  <li><details><summary><a href="/libs">Libraries</a></summary><ul> <li><a href="/libs/imagej-ops">ImageJ Ops</a></li> <li><a href="/libs/imagej-common">ImageJ Common</a></li> <li><a href="/libs/imagej-legacy">ImageJ Legacy</a></li> <li><a href="/libs/scijava">SciJava</a></li> <li><a href="/libs/scifio">SCIFIO</a></li> <li><details><summary><a href="/libs/imglib2">ImgLib2</a></summary><ul> <li><a href="/libs/imglib2/getting-started">Getting Started</a></li> <li><a href="/libs/imglib2/accessors">Accessors</a></li> <li><a href="/libs/imglib2/accessibles">Accessibles</a></li> <li><a href="/libs/imglib2/examples">Examples</a></li> <li><a href="/libs/imglib2/workshop-introductory">Introductory Workshop</a></li> <li><a href="/libs/imglib2/workshop-advanced">Advanced Workshop</a></li> <li><a href="/libs/imglib2/matlab">ImgLib2 images in MATLAB</a></li> <li><a href="/libs/imglib2/benchmarks">Benchmarks</a></li> <li><a href="/libs/imglib2/faq">FAQ</a></li> <li><a href="/libs/imglib2/developing">Developing ImgLib2</a></li> <li><a href="/libs/imglib2/discussion">ImgLib2 Discussion</a></li> </ul></details></li>  <li><a href="/libs">More...</a></li> </ul></details></li>  <li><details><summary><a href="/software">Software</a></summary><ul> <li><a href="/software/nih-image">NIH Image</a></li> <li><a href="/software/imagej">ImageJ</a></li> <li><a href="/software/imagej2">ImageJ2</a></li> <li><a href="/software/fiji">Fiji</a></li> <li><a href="/software">More...</a></li> </ul></details></li>  </ul></details></li>  </ul> </div> </section> <section id="right-column" class="sidebar dock">   <div id="toc" class="toc menu dockable"> <div class="drag-handle"></div> <h3>Page contents</h3> <ul data-toc="#content" data-toc-headings="h1,h2,h3,h4,h5,h6"></ul> </div> </section>  <div class="container"> <header class="major special"> <a class="project-icon shadowed-box" href="/software/imagej2"><img src="/media/icons/imagej2.png">This page describes content relating to the ImageJ2 platform. Click the logo for details.</a> <h1>Clojure Scripting</h1> </header> </div>   <section id="page" class="main style1"> <div class="container"> <div class="box alt"></div> <div id="content" class="page-content"> <div class="notice" style="font-size: 2; background: #ebf2f8; border-left: 10px solid #67a1fe"><div class="notice-icon"><img src="/media/icons/info.svg" width="32"></div><div class="notice-content">The content of this page has not been vetted since shifting away from MediaWiki. If you’d like to help, check out the <a href="/events/wiki-grand-opening/how-to-help">how to help guide</a>! </div> </div> <a href="https://en.wikipedia.org/wiki/Clojure">Clojure</a> is a dialect of the <a href="https://en.wikipedia.org/wiki/Lisp_(programming_language)">Lisp programming language</a>. Clojure is a general-purpose programming language with an emphasis on functional programming. <h1 id="clojure-tutorial-for-imagej">Clojure tutorial for ImageJ</h1> Check out <a href="http://clojure.org">clojure website</a> and particularly the chapter on <a href="http://clojure.org/java_interop">Java interoperability</a>. Clojure is not a scripting language: Clojure compiles directly to JVM bytecode, and thus runs at native speed. Thus one must think of Clojure as a true alternative to Java the language, but much more expressive, flexible and powerful. See also: <ul> <li><a href="http://en.wikibooks.org/wiki/Clojure_Programming/Examples/Cookbook">Clojure Cookbook</a>.</li> <li><a href="http://clojure.org/api">The Clojure API</a> (listing of all available functions, with explanations).</li> <li><a href="http://clojure.org/cheatsheet">Clojure cheat sheet</a>: a summary of all the essentials.</li> </ul> <h2 id="using-clojure-inside-fiji">Using Clojure inside Fiji</h2> Go to Plugins › Scripting › Clojure Interpreter. The prompt accepts any clojure code. See also the <a href="/scripting/script-editor">Script Editor</a>. See <a href="/scripting">Scripting Help</a> for details on keybindings and how to use the interpreter. <kbd class="key">⌃ Ctrl</kbd> + <kbd class="key">)</kbd> will add all necessary ending parenthesis. A minimal, complete clojure example: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(import '(ij IJ)) (def gold (IJ/openImage "https://imagej.net/ij/images/AuPbSn40.jpg")) (.show gold) </code></pre></div></div> To create scripts, just save them as .clj text files (with an underscore in the name) in any folder or subfolder of the <code class="language-plaintext highlighter-rouge">plugins</code> folder, and run Plugins › Scripting › Refresh Clojure Scripts to update the menus (it’s done automatically at start up as well). To edit a script, just edit and save it with your favorite text editor. To execute a script, do any of: <ul> <li>Select it from the plugins menus.</li> <li>Type ‘l’ (L), start typing its name, push the down arrow and then return to execute it.</li> <li>If it was the last executed command, just type <kbd class="key">⇧ Shift</kbd> + <kbd class="key">R</kbd> (shortcut to “Process - Repeat Command”).</li> </ul> The script is always read directly from the source file, so no updating of menus is needed (unless its file name changes). <h3 id="convenient-clojure-with-funimage">Convenient Clojure with Funimage</h3> <ul> <li><a href="https://github.com/funimage/funimage/">Funimage</a> provides a library for convenient Clojure coding within <a href="/software/imagej2">ImageJ2</a>. Alleviating much of the need for type-hinting, and some of the burdens involved in handling more complicated data structures, such as those from <a href="/libs/imglib2">ImgLib2</a>.</li> </ul> See the <a href="/list-of-update-sites">list of update sites</a> for information on setting up the Funimage update site. <h3 id="running-clojure-files-from-the-command-line">Running Clojure files from the command line</h3> ImageJ2 can execute any clojure file directly: <div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code>./ImageJ-linux64 plugins/Examples/blend_two_images.clj </code></pre></div></div> The file will run with the full classpath as set by ImageJ2, which includes all jars in <code class="language-plaintext highlighter-rouge">jars/</code> and <code class="language-plaintext highlighter-rouge">plugins/</code> folders, among others. <h2 id="language-basics">Language basics</h2> <ul> <li>A ‘;’ defines the start of a comment, just like ‘//’ does in Java.</li> <li>A function definition declares parameters within [].</li> <li>Local variables are declared with <code class="language-plaintext highlighter-rouge">let</code>, and global variables with <code class="language-plaintext highlighter-rouge">def</code>.</li> <li>Functions are defined with <code class="language-plaintext highlighter-rouge">defn</code>, and are visible globally. Hence a function declared within a <code class="language-plaintext highlighter-rouge">let</code> statement has access to variables declared in it. This method enables closures.</li> </ul> <h3 id="importing-classes">Importing classes</h3> To reference Java classes from Clojure you will need to import them. <div class="notice" style="font-size: 2; background: #e6e6e6; border-left: 10px solid #fadd8d"><div class="notice-icon"><img src="/media/icons/imagej2.png" /></div><div class="notice-content">Unlike the original <a href="/software/imagej">ImageJ</a>, <a href="/software/imagej2">ImageJ2</a> (and therefore <a href="/software/fiji">Fiji</a>) does not automatically import any classes. Consequently, scripts written for ImageJ will not run in ImageJ2 without adding the proper imports. The rationale is that the auto-import feature is not safe. What if two classes of the same name live in two different packages? Or if a new class is introduced that makes formerly unique names ambiguous? All of a sudden, all of the scripts that reference the original class no longer work. In short: auto-imports are dangerously imprecise. </div> </div> You can specify imports in Clojure in a few ways: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; A single import. (import java.util.Date) ; Use it! (def *now* (Date.)) (str *now*) ; Multiple imports at once. (import '(java.util Date Calendar) '(java.net URI ServerSocket) java.sql.DriverManager) ; Import multiple classes in a namespace. (ns foo.bar (:import (java.util Date Calendar) (java.util.logging Logger Level))) </code></pre></div></div> <h2 id="calling-methods-and-variables-on-a-java-object">Calling methods and variables on a java object</h2> There are two ways, the second syntactic sugar of the first. Below, <code class="language-plaintext highlighter-rouge">imp</code> is a pointer to an ImagePlus: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; java-ish way: (. imp (getProcessor)) ; shorter java-ish way: (. imp getProcessor) ; lisp-ish way: (.getProcessor imp) </code></pre></div></div> To call a method on an object returned by a method call, there is a simplified way: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; double way: (. (. imp (getProcessor)) (getPixels)) ; simplified double way: (.. imp (getProcessor) (getPixels)) ; super simplified (less parenthesis than java!) (.. imp getProcessor getPixels) ; or lisp-ish way: (.getPixels (.getProcessor imp)) </code></pre></div></div> Any number of concatenated method calls, both for static methods or for instances: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; Concatenated call to static and instance methods (.. WindowManager getCurrentImage getProcessor getPixels) </code></pre></div></div> To call a variable or ‘field’, just do it like a method call but without the parentheses: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(. imp changes) </code></pre></div></div> or more lisp-ish: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(.changes imp) </code></pre></div></div> To enhance readability, use <code class="language-plaintext highlighter-rouge">import</code> when appropriate. Imports remain visible throughout the current namespace: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(import '(java.awt Color Rectangle) '(ij.plugin.filter PlugInFilter)) (new Rectangle 0 0 500 500) ; It's the same as: (Rectangle. 0 0 500 500) ; A static field, call like a namespace: PlugInFilter/DOES_ALL </code></pre></div></div> Choose whatever matches your mental schemes best. <h2 id="calling-static-fields-and-methods-namespace-syntax">Calling static fields and methods: namespace syntax</h2> To call a <code class="language-plaintext highlighter-rouge">static</code> field or method, use namespace syntax: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(println "does all: " ij.plugin.filter.PlugInFilter/DOES_ALL) (ij.IJ/log "Some logged text") </code></pre></div></div> Above, notice how a class name is used instead of a pointer to call static fields and methods. Static fields and methods are just variables and functions that exist within the namespace of the class in which they are declared. Hence Clojure’s namespace syntax makes way more sense than java code, that doesn’t do such distinction and allows for loads of confusion (java allows invoking static methods and fields using a pointer to an instance of the class in which such static methods and fields are declared). <h2 id="defining-variables-obtaining-the-current-image">Defining variables: obtaining the current image</h2> As a local variable <code class="language-plaintext highlighter-rouge">imp</code> declared within a <code class="language-plaintext highlighter-rouge">let</code> statement: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [imp (ij.WindowManager/getCurrentImage)] ; print its name (println (.getTitle imp))) ; Variable imp NOT visible from outside let statement: (println (.getTitle imp)) ---> ERROR </code></pre></div></div> As a general variable visible from the entire namespace: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(def *imp* (ij.WindowManager/getCurrentImage)) (println (.getTitle *imp*)) </code></pre></div></div> By convention, in lisp global variables are written with asterisks in the name. A <code class="language-plaintext highlighter-rouge">let</code> statement lets you declare any number of paired variable name / values, even referring to each other in sequence: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [imp (ij.WindowManager/getCurrentImage) ip (.getProcessor imp) pix (.getPixels ip) pix2 (.getPixels (.getProcessor imp))] ; do some processing ... (println (str "number of pixels: " (count pix)))) </code></pre></div></div> Any number of <code class="language-plaintext highlighter-rouge">let</code> statements may be nested together: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [imp (ij.WindowManager/getCurrentImage)] ; do whatever processing here (let [ip (.getProcessor imp] ; print first pixel (println (str (.getPixel ip 0 0)))))) </code></pre></div></div> <h2 id="creating-objects-invoking-constructors">Creating objects: invoking constructors</h2> A constructor is invoked by adding a dot ‘.’ to the name of a class, followed by the arguments. Below, we create an ImageProcessor and then an ImagePlus with it, and finally we print the ImagePlus, which invokes toString() on it (like in java): <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [ip (ij.process.ByteProcessor. 400 400) imp (ij.ImagePlus. "my image" ip)] (println imp)) </code></pre></div></div> An alternative syntax is to use the java-like <code class="language-plaintext highlighter-rouge">new</code> keyword, but it’s unnecessarily verbose: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [ip (new ij.process.ByteProcessor 400 400) imp (new ij.ImagePlus "my image" ip)] (println imp)) </code></pre></div></div> <h2 id="defining-a-closure">Defining a closure</h2> In the following a function is declared within the scope of the local variable <code class="language-plaintext highlighter-rouge">rand</code>, which contains an instance of java.util.Random. All calls to the function <code class="language-plaintext highlighter-rouge">rand-double</code> will use the same random number generator instance with seed 69997. The <code class="language-plaintext highlighter-rouge">dotimes</code> loop will then print 10 different pseudo-random numbers. If the <code class="language-plaintext highlighter-rouge">rand</code> was a new Random with seed 69997 every time, all 10 numbers would be exactly the same. You can think of a function inside a closure as a static function using a static variable (in Java), but it’s more than that, since the function will be able to access parameters on the global namespace and also in any other local namespace in which the <code class="language-plaintext highlighter-rouge">let</code> is declared. For example, another <code class="language-plaintext highlighter-rouge">let</code>, or even another <code class="language-plaintext highlighter-rouge">defn</code>! <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [rand (java.util.Random. 69997)] (defn rand-double [] (.nextDouble rand))) (dotimes [i 10] (println (rand-double))) </code></pre></div></div> Above, note the dot ‘.’ after Random, which indicates we are calling the constructor (with a single parameter 69997, the pseudorandom generator seed to be used). Alternatively, one may use the java-like syntax: (new java.util.Random 69997) – note the absence of a dot now. <h2 id="manipulating-images">Manipulating images</h2> <h3 id="imagej-image-internals-imageplus-imageprocessor-imagestack">ImageJ Image internals: ImagePlus, ImageProcessor, ImageStack</h3> ImageJ has three basic objects: <ul> <li>The <a href="https://imagej.net/ij/developer/api/ij/ImagePlus.html"><code class="language-plaintext highlighter-rouge">ImagePlus</code></a>, which wraps the ImageProcessor and contains properties and pointers to the ROI (region of interest) and the ImageWindow that may be displaying the image.</li> <li>The <a href="https://imagej.net/ij/developer/api/ij/process/ImageProcessor.html"><code class="language-plaintext highlighter-rouge">ImageProcessor</code></a>, which is an abstract class enabling the high-level manipulation of and access to pixels. Its subclasses each wraps a different kind of data type: <ul> <li><code class="language-plaintext highlighter-rouge">ByteProcessor</code> - <code class="language-plaintext highlighter-rouge">byte[]</code></li> <li><code class="language-plaintext highlighter-rouge">ShortProcessor</code> - <code class="language-plaintext highlighter-rouge">short[]</code></li> <li><code class="language-plaintext highlighter-rouge">FloatProcessor</code> - <code class="language-plaintext highlighter-rouge">float[]</code></li> <li><code class="language-plaintext highlighter-rouge">ColorProcessor</code> - <code class="language-plaintext highlighter-rouge">int[]</code> (byte-packed ARGB, but Alpha channel is ignored)</li> </ul> </li> <li>The <a href="https://imagej.net/ij/developer/api/ij/ImageStack.html"><code class="language-plaintext highlighter-rouge">ImageStack</code></a> which contains unfortunately not an array of <code class="language-plaintext highlighter-rouge">ImageProcessor,</code> but an <code class="language-plaintext highlighter-rouge">Object[]</code> containing an homogeneous list of equal length <code class="language-plaintext highlighter-rouge">byte[]</code>, or <code class="language-plaintext highlighter-rouge">float[]</code>, etc.</li> </ul> For extensive documentation, see the <a href="http://albert.rierol.net/imagej_programming_tutorials.html#ImageJ%20programming%20basics">Anatomy of an ImageJ image</a> ImageJ programming basics tutorial. <h3 id="conventions-in-naming-image-variables">Conventions in naming image variables</h3> By convention, variables are named: <ul> <li><code class="language-plaintext highlighter-rouge">imp</code> to mean ImagePlus</li> <li><code class="language-plaintext highlighter-rouge">ip</code> to mean ImageProcessor</li> <li><code class="language-plaintext highlighter-rouge">stack</code> to mean ImageStack</li> </ul> <h3 id="creating-a-new-image">Creating a new image</h3> From scratch: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(import '(ij ImagePlus) '(ij.process ByteProcessor)) (let [imp (ImagePlus. "A new image" (ByteProcessor. 400 400))] (.show imp)) </code></pre></div></div> From a file: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [imp (IJ/openImage "/path/to/an/image.tif")] (.show imp)) </code></pre></div></div> <h3 id="creating-an-image-of-the-same-type-of-an-existing-one">Creating an image of the same type of an existing one</h3> <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; The original (def imp-1 (ImagePlus. "The source image" (FloatProcessor. 512 512))) ; The new empty image, of the same type as the old but larger (def imp-2 (ImagePlus. "The larger image of the same type" (.. imp-1 getProcessor (createProcessor 768 768)))) </code></pre></div></div> Above, notice the parenthesis (createProcessor 768 768), which specify for which method those numbers are arguments for. <h3 id="resizing-an-image">Resizing an image</h3> The idea is to grab the ImageProcessor, duplicate it and resize it. The resizing returns a new ImageProcessor of the same type: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(def imp-1 (IJ/openImage "/path/to/image1.tif")) (def imp-2 (ImagePlus. "A new larger one" (.. imp-1 getProcessor (createProcessor 1024 1024)))) ; Copy one into the other at top-left (hence 0,0 insert point): (doto (.getProcessor imp-2) (.insert (.getProcessor imp-1) 0 0)) </code></pre></div></div> An alternative way would be to simply duplicate the processor of imp-1, and then enlarge it: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(def imp-3 (ImagePlus. "A copy with extra empty space" (.. imp-1 getProcessor duplicate (resize 768 768))) </code></pre></div></div> <h3 id="resizing-an-imagestack">Resizing an ImageStack</h3> This one is harder, because an ImageStack is just a wrapper for Object[] list of pixel arrays. ImageJ though provides a mid-level resizing method, via the <a href="https://imagej.net/ij/developer/api/ij/plugin/CanvasResizer.html">CanvasResizer</a> class: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(import '(ij.plugin CanvasResizer) '(ij IJ ImagePlus)) ; Grab the image in the currently active ImageWindow: (def imp-1 (IJ/getImage)) ; function to resize images: (defn resize-image "Takes an ImagePlus as argument and returns a new ImagePlus but resized to width,height, and with the contents copied starting from xoff,yoff" [imp w h xoff yoff] (let [resizer (CanvasResizer.) stack (.getStack imp) imp-2 (ImagePlus. (.getTitle imp) (if stack (.expandStack resizer stack w h xoff yoff) (.expandProcessor resizer w h xoff yoff)))] imp-2)) (def imp-2 (resize-image imp-1 1024 1024 0 0)) (.show imp-2) </code></pre></div></div> Note that the above function <code class="language-plaintext highlighter-rouge">resize-image</code> will work for both stacks and non-stack images. Of course nothing stops you from looping through the stack length, calling a new ImageProcessor for each slice, resizing it, composing a new ImageStack and with it a new ImagePlus. <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; Grab the image in the currently active ImageWindow: (def imp-1 (IJ/getImage)) (defn resize-stack "Resize an ImageStack to new widht,height and copy its contents starting at xoff,yoff coordinate." [stack w h xoff yoff] (let [new-stack (ImageStack. w h nil)] (doseq [i (range 0 (.getSize stack))] (let [ip (.getProcessor stack (+ i 1)) #^ImageProcessor ip2 (.createProcessor ip w h)] (.insert ip2 ip xoff yoff) (.addSlice new-stack (str i) ip2))) new-stack)) </code></pre></div></div> Above, note that stacks are 1-based,not 0-based! Also, we must declare the type of the <code class="language-plaintext highlighter-rouge">ip2</code> because clojure cannot decide between the ImageProcessor.addSlice(String,ImageProcessor) and ImageProcessor.addSlice(String,Object). You must make that choice for clojure. Notice that each time you call getProcessor on an ImageStack, it returns a new ImageProcessor instance in a very costly way, by calling a series of <code class="language-plaintext highlighter-rouge">instanceof</code> on the pixels arrays to figure out which kind of ImageProcessor subclass it should create. <h3 id="resizing-an-image-or-imagestack-using-rois">Resizing an image or ImageStack using ROIs</h3> ROIs (aka Region of Interest or selection) have bounds, defined by the minimal enclosing rectangle. The core idea is to set a ROI to an ImageProcessor and call <code class="language-plaintext highlighter-rouge">crop</code> to obtain a new, subcopy of it. <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(def imp (IJ/getImage)) (def imp-cropped (ImagePlus. "Cropped" (let [ip (.getProcessor imp)] (.setRoi ip (Roi. 10 10 200 200)) (.crop ip)))) (.show imp-cropped) </code></pre></div></div> To handle any ImagePlus (with single slice or containing an ImageStack, i.e. many slices), see this function: (which assumes the ROI is contained fully within the image; otherwise for stacks it will throw an Exception stating that, rightly, dimensions do not match.) <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(import '(ij.gui Roi) '(ij ImagePlus) '(ij.process ImageProcessor)) (def imp (IJ/getImage)) (defn crop-image "Crop an image by the bounds of a ROI, returning a new ImagePlus with the result." [imp roi] (let [crop-processor (fn [ip roi] (.setRoi ip roi) (.crop ip)) stack (.getStack imp)] ; Return a new ImagePlus with a new cropped ImageProcessor ; or a new cropped ImageStack: (ImagePlus. (.getTitle imp) (if stack (let [box (.getBounds roi) new-stack (ImageStack. (.width box) (.height box) nil)] (doseq [i (range (.getSize stack))] (.addSlice new-stack (.getSliceLabel stack (+ i 1)) #^ImageProcessor (crop-processor (.getProcessor stack (+ i 1)) roi))) new-stack) ; Else single slice image: (crop-processor (.getProcessor imp) roi))))) (def imp-cropped (crop-image imp (Roi. 100 100 300 300)) (.show imp-cropped) </code></pre></div></div> The above works with both single images and stacks. <h2 id="manipulate-images-using-imglib">Manipulate images using ImgLib</h2> With <a href="/libs/imglib1">Imglib</a>, pixels are stored in native arrays of primitives such as int, float, double, etc. (or other more interesting forms, such as <a href="http://download.oracle.com/javase/1.5.0/docs/api/java/awt/Shape.html">Shape</a>. Such pixels are accessed with intermediate proxy objects that the JIT is able to completely remove out of the way. From Clojure, there are many ways in which to access the pixels. Here we list some examples of the pixels accessed as a Collection of accessor <a href="https://fiji.sc/javadoc/mpicbg/imglib/type/Type.html">Type</a> objects. <h3 id="multiply-each-pixel-by-05">Multiply each pixel by 0.5</h3> Multiply in place each value by 0.5. The ImgLib/wrap is a thin wrapper that accesses directly the pixel array. Hence the original image will be changed. <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; ASSUMES the current image is 32-bit (ns test.imglib (:import [mpicbg.imglib.image Image] [script.imglib ImgLib] [mpicbg.imglib.type.numeric.real FloatType] [ij IJ])) (set! *warn-on-reflection* true) (let [^Image img (ImgLib/wrap (IJ/getImage)) a (float 0.5)] (doseq [^FloatType t img] (.mul t a))) </code></pre></div></div> In a more functional style, below we create an image with the same dimensions as the wrapped image, and set its pixel values to those of the original image times 0.5: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(ns test.imglib (:import [mpicbg.imglib.image Image] [mpicbg.imglib.cursor Cursor] [script.imglib ImgLib] [mpicbg.imglib.type.numeric NumericType] [ij IJ])) (set! *warn-on-reflection* true) (let [^Image img (ImgLib/wrap (IJ/getImage)) a (float 0.5) ^Image copy (.createNewImage img "copy")] (with-open [^Cursor c1 (.createCursor img) ^Cursor c2 (.createCursor copy)] (loop [] (if (.hasNext c1) (do (.fwd c1) (.fwd c2) (let [^NumericType t1 (.getType c1) ^NumericType t2 (.getType c2)] (.set t2 t1) (.mul t2 a)) (recur))))) (.. copy getDisplay setMinMax) (.show (ImgLib/wrap copy))) </code></pre></div></div> The above, though, is unbearably verbose. A high-level access to the images enables mathematical operations without trading off any performance: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(ns test.imglib (:import [mpicbg.imglib.image Image] [mpicbg.imglib.cursor Cursor] [script.imglib ImgLib] [script.imglib.math Compute Multiply] [ij IJ])) (set! *warn-on-reflection* true) (let [^Image img (ImgLib/wrap (IJ/getImage)) ^Image copy (Compute/inFloats (Multiply. img 0.5))] (.. copy getDisplay setMinMax) (.show (ImgLib/wrap copy))) </code></pre></div></div> What’s more, the <a href="https://fiji.sc/javadoc/script/imglib/math/Compute.html">Compute</a>/inFloats method runs in parallel, with as many processors as your machine has cores. If you’d rather not execute the operation in parallel, add the desired number of threads as an argument to <code class="language-plaintext highlighter-rouge">inFloats</code>. All mathematical operations listed in java.lang.Math have a corresponding constructor for execution in Compute/inFloats. See the documentation for the <a href="https://fiji.sc/javadoc/script/imglib/math/package-frame.html">script.imglib.math package</a>. <h3 id="normalize-an-image">Normalize an image</h3> Assumes that <code class="language-plaintext highlighter-rouge">(IJ/getImage)</code> returns a 32-bit, float image. If that is not the case, convert the image to a float image first. The example below creates a new result image. The original image is untouched. This is accomplished with minimal friction but best performance (like hand-coded with cursors or better) by using the high-level scripting library of imglib, and the <a href="https://fiji.sc/javadoc/script/imglib/math/Compute.html">Compute</a>/inFloats method. <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(ns test.imglib (:import [mpicbg.imglib.image Image] [script.imglib ImgLib] [script.imglib.math Compute Subtract Divide] [ij IJ])) (let [^Image img (ImgLib/wrap (IJ/getImage)) size (.size img) mean (reduce #(+ %1 (/ (.getRealFloat %2) size)) (float 0) img) variance (/ (reduce #(+ %1 (Math/pow (- (.getRealFloat %2) mean) (float 2))) (float 0) img) size) std-dev (Math/sqrt variance) ^Image normalized (Compute/inFloats (Divide. (Subtract. img mean) std-dev))] (.. normalized getDisplay setMinMax) (.show (ImgLib/wrap normalized))) </code></pre></div></div> There is a better way to compute the mean and variance of a collection of numbers, that involves traversing the collection only once. Clojure naturally helps with its very concise destructuring and its automatic promotion of numeric types to avoid overflow. <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(ns test.imglib (:import [mpicbg.imglib.image Image] [mpicbg.imglib.type.numeric RealType] [script.imglib ImgLib] [script.imglib.math Compute Subtract Divide] [ij IJ])) (set! *warn-on-reflection* true) (let [^Image img (ImgLib/wrap (IJ/getImage)) size (.size img) [xs x2s] (reduce (fn [accum ^RealType t] (let [xi (.getRealFloat t)] [(+ (accum 0) xi) (+ (accum 1) (* xi xi))])) [0 0] img) mean (/ xs size) variance (- (/ x2s size) (* mean mean)) std-dev (Math/sqrt variance) ^Image normalized (Compute/inFloats (Divide. (Subtract. img mean) std-dev))] (.. normalized getDisplay setMinMax) (.show (ImgLib/wrap normalized))) </code></pre></div></div> (Code adapted from a Common Lisp version by <a href="http://nklein.com/2011/02/calculating-the-mean-and-variance-with-one-pass/">Patrick Stein</a>.) <h2 id="looping-an-array-of-pixels">Looping an array of pixels</h2> For example, to find the min and max values: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; Obtain the pixels array from the current image (let [imp (ij.WindowManager/getCurrentImage) pixels (.. imp getProcessor getPixels) min (apply min pixels) max (apply max pixels)] (println (str "min: " min ", max: " max))) </code></pre></div></div> The above code does not explicitly loop the pixels: it simply applies a function to an array. To loop pixels one by one, use any of the following: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [imp (ij.WindowManager/getCurrentImage) pixels (.. imp getProcessor getPixels)] ; First loop with "dotimes" (dotimes [i (count pixels)] (println (aget pixels i))) ; Second loop: with "loop -- recur" (loop [i 0 len (count pixels)] (if (< i len) (do (println (str i ": " (aget pixels i))) (recur (inc i) len))))) </code></pre></div></div> Above, notice that the <code class="language-plaintext highlighter-rouge">loop -- recur</code> construct is essentially a <code class="language-plaintext highlighter-rouge">let</code> declaration, with a second call (<code class="language-plaintext highlighter-rouge">recur</code>) to reset the variables to something else. In this case, the next index in the array. Note how the len is simply given the same value over and over, just to avoid calling <code class="language-plaintext highlighter-rouge">(count pixels)</code> at each iteration. Of course, there are lispier ways to loop an array of pixels. For example, to obtain the average of all pixels, we can use function <code class="language-plaintext highlighter-rouge">reduce</code>, which takes the first two elements of a list, applies a function to them, and then applies the function to the result and the next element, etc: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [fp (.getProcessor (ij.IJ/getImage)) pix (.getPixels fp)] (if (instance? ij.process.FloatProcessor fp) (println "Average pixel intensity" (/ (reduce + pix) (count pix))) (println "Not a 32-bit image"))) </code></pre></div></div> Above, notice that one could have used also <code class="language-plaintext highlighter-rouge">apply</code> to apply <code class="language-plaintext highlighter-rouge">+</code> to all element of an array, with the same result: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code> (println "Average pixel intensity" (/ (apply + pix) (count pix))) </code></pre></div></div> To sum all pixels in an 8-bit image, one needs first to bit-and all bytes to 255, so they become integers and can be summed. But of course we should not <code class="language-plaintext highlighter-rouge">bit-and</code> the sum! To solve this, <code class="language-plaintext highlighter-rouge">reduce</code> accepts a first value (in this case, zero): <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [bp (.getProcessor (ij.IJ/getImage)) pix (.getPixels bp)] (if (instance? ij.process.ByteProcessor bp) (println "Average intensity: " (float (/ (reduce (fn [x1 x2] (+ x1 (bit-and x2 255))) 0 pix) (count pix)))) (println "Not an 8-bit image"))) </code></pre></div></div> It could even be done using a local variable, but it’s ugly and undesirable (why create it when it’s not really needed)? Notice we need to create the local variable “sum” because variables declared by <code class="language-plaintext highlighter-rouge">let</code> are immutable. <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [bp (.getProcessor (ij.IJ/getImage)) pix (.getPixels bp)] (if (instance? ij.process.ByteProcessor bp) (with-local-vars (sum 0) (doseq [pixel pix] (var-set sum (+ (var-get sum) (bit-and pixel 255)))) (println (float (/ (var-get sum) (count pix))))) (println "Not an 8-bit image"))) </code></pre></div></div> <h2 id="executing-commands-from-the-menus">Executing commands from the menus</h2> Any ImageJ menu command may be run on the active image: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(ij.IJ/doCommand "Add Noise") </code></pre></div></div> Be aware that the above starts a new Thread and forks. For reliable control, try the run method, which will wait until the plugin finishes execution. <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(ij.IJ/run "Add Noise") </code></pre></div></div> For even more reliable control, run the command directly on a specified image, instead of a possibly changing current image: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [imp (ij.IJ/getImage)] (ij.IJ/run imp "Subtract..." "value=25")) </code></pre></div></div> To find out which arguments can any command accept, open the Plugins - Macros - Macro Recorder and run the command manually. <h2 id="creating-and-using-clojure-scripts-as-imagej-plugins">Creating and using Clojure scripts as ImageJ plugins</h2> Simply create a text file with the script inside, and place it in the plugins menu or any subfolder. Then call Plugins - Scripting - Refresh Clojure Scripts to make it appear on the menus. If the macros/StartupMacros.txt includes a call to the Refresh Clojure Scripts inside the AutoRun macro, then all your Clojure scripts will appear automatically on startup. To modify an script which exists already as a menu item, simply edit its file and run it by selecting it from the menus. No compiling necessary, and no need to call Refresh Clojure Scripts either (ther latter only for new scripts or at start up.) <div class="notice" style="font-size: 2; background: #ffcccb; border-left: 10px solid #f57900"><div class="notice-icon"><img src="/media/icons/warning.png" /></div><div class="notice-content">All scripts and commands from the interpreter will run within the same thread, and within the same clojure context. </div> </div> <h2 id="using-java-beans-for-quick-and-convenient-access-to-an-objects-fields">Using java beans for quick and convenient access to an object’s fields</h2> Essentially it’s all about using <code class="language-plaintext highlighter-rouge">get</code> methods in a trivial way. For example: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [imp (ij.WindowManager/getCurrentImage) b (bean imp)] (println (:title b) (:width b) (:height b))) </code></pre></div></div> Eventually Clojure may add support for <code class="language-plaintext highlighter-rouge">set</code> methods as well. <h1> Examples </h1> <h2 id="fixing-overexposed-images-setting-a-pixel-value-to-a-desirable-one-for-all-overexposed-pixels">Fixing overexposed images: setting a pixel value to a desirable one for all overexposed pixels</h2> The problem: <a href="http://ami.scripps.edu/software/leginon/">Leginon</a> or the Gatan TEM camera acquired an overexposed image, and set all pixels beyond range to zero. The solution: iterate all pixels; if the pixel is zero then set it to a desirable value, such as the maximum value of the main curve in the histogram (push ‘auto’ on the Brightness and Contrast dialog to see it.) In the example below, the <code class="language-plaintext highlighter-rouge">fix</code> function is called with the current image and the value 32500 as a floating point number. Notice also the type definition (which is optional) of the float pixel array, to enhance execution speed: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; Assumes a FloatProcessor image (defn fix [imp max] (let [#^floats pix (.getPixels (.getProcessor imp))] (loop [i (int 0)] (if (< i (alength pix)) (do (if (= 0 (aget pix i)) (aset pix i (float max))) (recur (inc i))))))) (let [imp (ij.IJ/getImage)] (fix imp (float 32500)) (.updateAndDraw imp)) </code></pre></div></div> <h2 id="creating-a-script-for-imagej">Creating a script for ImageJ</h2> Simply write the clojure script in a text file, and follow these conventions: <ol> <li>Add an underscore <code class="language-plaintext highlighter-rouge">_</code> to its file name, and the extension <code class="language-plaintext highlighter-rouge">.clj</code>: <code class="language-plaintext highlighter-rouge">fix_leginon_images.clj</code></li> <li>Save it under <code class="language-plaintext highlighter-rouge">fiji/plugins/</code> folder, or a subfolder.</li> </ol> When done, just run the PlugIns › Scripting › Refresh Clojure Scripts plugin. Once saved and in the menus, you need not call refresh scripts ever again for that script. Just edit and save it’s text file, and run it again from the menus. Next time ImageJ2 opens, the script will automatically appear in the menus. See <a href="/scripting">Scripting Help</a> for more details, including how to use the built-in dynamic interpreter. <h2 id="example-clojure-plugins-included-in-fiji">Example Clojure plugins included in Fiji</h2> The <a href="/software/fiji">Fiji</a> distribution of ImageJ2 includes some Clojure examples: <ul> <li><a href="https://github.com/fiji/fiji/blob/master/plugins/Examples/Multithreaded_Image_Processing.clj">Multithreaded_Image_Processing.clj</a>: illustrate, with macros (via <a href="http://clojure.org/macros#toc9">defmacro</a>), how to automatically multithread the processing of an image using arbitrary subdivision of the image, such as one line per thread, for as many threads as cores the CPU has.</li> <li><a href="https://github.com/fiji/fiji/blob/master/plugins/Examples/blend_two_images.clj">blend_two_images.clj</a>: illustrates how to open two images from an URL, and blend the gray image into each channel of the color image.</li> <li><a href="https://github.com/fiji/fiji/blob/master/plugins/Examples/celsius_to_fahrenheit.clj">celsius_to_fahrenheit.clj</a>: illustrates the usage of a Swing GUI, and how to instantiate anonymous classes from an interface (via <a href="http://clojure.org/java_interop#toc20">proxy</a> Clojure function). This example is taken from the <a href="http://clojure.org/jvm_hosted">Clojure website</a>.</li> <li><a href="https://github.com/fiji/fiji/blob/master/plugins/Examples/random_noise_example.clj">random_noise_example.clj</a>: illustrates how to declare a function inside a closure (for private access to, in this case, a unique instance of a random number generator), and then fill all pixels of a ByteProcessor image with a random byte value.</li> <li><a href="https://github.com/fiji/fiji/blob/master/plugins/Examples/Command_Launchers/Command_Launcher_Clojure.clj">Command_Launcher_Clojure.clj</a>: illustrates how to create a GUI with a KeyListener, so that the typed text changes color from red to black when it matches the name of an ImageJ command. This example is also under the <a href="/scripting/comparisons">Scripting comparisons</a>, along equivalent versions written in Java, <a href="/scripting/jython">Jython</a>, <a href="/scripting/javascript">Javascript</a> and <a href="/scripting/jruby">JRuby</a>.</li> <li><a href="https://github.com/fiji/fiji/blob/master/plugins/Analyze/Dynamic_ROI_Profiler.clj">Dynamic ROI Profiler</a>: illustrates how to add a MouseMotionListener and a WindowListener to an ImageWindow of an open image. Reads out the ROI (Region Of Interest), and if it’s a line, polyline or rectangle, plots the profile of pixel intensity along the line. As the mouse moves or edits the ROI on the image, the profile is updated.</li> </ul> <h1> Appendix </h1> <h2 id="defining-the-output-stream">Defining the output stream</h2> The default output stream is at variable <code class="language-plaintext highlighter-rouge">*out*</code>, which you may redefine to any kind of PrintWriter: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [all-out (new java.io.StringWriter)] (binding [*out* all-out] ; any typed input here ; All calls to pr, prn, println will print into all-out (println "this and that") ) ; Now show any printed out text in ImageJ's log window: (ij.IJ/log (str all-out))) </code></pre></div></div> <h2 id="destructuring">Destructuring</h2> Destructuring is a shortcut to capture the contents of a variable into many variables. An example: when looping a map, we get the entry, not the key and value of each entry: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(doseq [e {:a 1 :b 2 :c 3}] (println e)) </code></pre></div></div> Prints: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>[:a 1] [:b 2] [:c 3] nil </code></pre></div></div> Each “entry” is represented by a vector with two values. Now to loop more conveniently, we can assign the key and value to variables, by what is called destructuring (note the <code class="language-plaintext highlighter-rouge">[k v]</code> where the <code class="language-plaintext highlighter-rouge">e</code> was before) <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(doseq [[k v] {:a 1 :b 2 :c 3}] (println k v)) </code></pre></div></div> Prints: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>:a 1 :b 2 :c 3 nil </code></pre></div></div> Even better, we can preserve the whole entry as well, by using the keyword “:as”: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(doseq [[k v :as e] {:a 1 :b 2 :c 3}] (println k v e)) </code></pre></div></div> Prints: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>:a 1 [:a 1] :b 2 [:b 2] :c 3 [:c 3] nil </code></pre></div></div> <h2 id="namespaces">Namespaces</h2> <ul> <li> To list all existing namespaces: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>>>> (all-ns) (#<Namespace: xml> #<Namespace: zip> #<Namespace: clojure> #<Namespace: set> #<Namespace: user>) </code></pre></div> </div> </li> <li> To list all functions and variables of a specific namespace, first get the namespace object by name: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(ns-map (find-ns 'xml)) </code></pre></div> </div> </li> </ul> Note above the quoted string “xml” to avoid evaluating it to a (non-existing) value. <ul> <li> To list all functions and variables of all namespaces: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(map ns-map (all-ns)) </code></pre></div> </div> </li> </ul> A nicer way to print all public functions and variables from all namespaces, sorted alphabetically: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(doseq [name (all-ns)] (doseq [[k v] (sort (ns-publics name))] (println k v))) </code></pre></div></div> Note above we use destructuring: the <code class="language-plaintext highlighter-rouge">[k v]</code> take the values of the key and the value of each entry in the ns-publics table. Actually, since we first sort the table, the <code class="language-plaintext highlighter-rouge">k</code> and <code class="language-plaintext highlighter-rouge">v</code> take the first and second values of each array pair in the sorted list of array pairs returned on applying <code class="language-plaintext highlighter-rouge">sort</code> to the <code class="language-plaintext highlighter-rouge">ns-publics</code>-generated table. <h2 id="forgetremove-all-variables-from-a-namespace">Forget/Remove all variables from a namespace</h2> To forget all variables from the user namespace, do: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(map #(ns-unmap 'user %) (keys (ns-interns 'user))) </code></pre></div></div> The above maps the function <code class="language-plaintext highlighter-rouge">ns-unmap</code> to each variable name declared in the <code class="language-plaintext highlighter-rouge">user</code> namespace (using # to create a <a href="/scripting/clojure#lambda-functions">lambda function</a>), which is the same as the prompt namespace. To get the names of the variables, we use <code class="language-plaintext highlighter-rouge">ns-interns</code> to retrieve the map of variable names versus the variable contents, and extract the keys from it into a list. Thanks to AWizzArd from #clojure at irc.freenode.net for the tip. <h2 id="jvm-arguments">JVM arguments</h2> <ul> <li> To get the arguments passed to the JVM, see contents of variable <code class="language-plaintext highlighter-rouge">command-line-args</code> <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(println *command-line-args*) </code></pre></div> </div> </li> </ul> <h2 id="reflection">Reflection</h2> <ul> <li> To list all methods of an object: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(defn print-java-methods [obj] (doseq [method (seq (.getMethods (if (= (class obj) java.lang.Class) (identity obj) (class obj))))] (println method))) ; Inspect an object named imp, perhaps an image (print-java-methods imp) public synchronized boolean ij.ImagePlus.lock() public void ij.ImagePlus.setProperty(java.lang.String,java.lang.Object) public java.lang.Object ij.ImagePlus.getProperty(java.lang.String) ... </code></pre></div> </div> </li> <li> To list constructors, just use <code class="language-plaintext highlighter-rouge">.getConstructors</code> instead of <code class="language-plaintext highlighter-rouge">.getMethods</code>. </li> </ul> (Thanks to Craig McDaniel for posting the above function to Clojure’s mailing list.) <h2 id="lambda-functions">Lambda functions</h2> <h3 id="declaration">Declaration</h3> <ul> <li>To declare functions on the fly, lambda style, with regex for arguments:</li> </ul> For example, declare a function that takes 2 arguments, and returns the value of the first argument divided by 10, and multiplied by the second argument: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [doer #(* (/ %1 10) %2)] (doer 3 2)) </code></pre></div></div> Of course there’s no need to name the function, the above is just for illustration. <h3 id="mapping-a-function-to-all-elements-in-a-list">Mapping a function to all elements in a list</h3> <ul> <li>To declare a nameless function, and apply it to each element of a list:</li> </ul> In this case, increment by one each value of a list from 0 to 9: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [numbers (range 10) add-one (fn [x] (+ x 1))] (map add-one numbers)) </code></pre></div></div> There is no need to declare the names, the above is just for illustration. Above, we could have defined the function as #(+ %1 1): <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(map #(+ %1 1) (range 10)) </code></pre></div></div> … or of course use the internal function <code class="language-plaintext highlighter-rouge">inc</code> which does exactly that: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(map inc (range 4)) </code></pre></div></div> Beware that the <code class="language-plaintext highlighter-rouge">map</code> function above applies the given function to each element of a list, and returns a new list with the results. <h2 id="built-in-documentation">Built-in documentation</h2> Use the function <code class="language-plaintext highlighter-rouge">doc</code> to query any other function or variable. For example, the list generator function <code class="language-plaintext highlighter-rouge">range</code>: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(doc range) ------------------------- clojure/range ([end] [start end] [start end step]) Returns a lazy seq of nums from start (inclusive) to end (exclusive), by step, where start defaults to 0 and step to 1. </code></pre></div></div> Above, notice the function has three groups of possible arguments, denoted in brackets. When not knowing what to search for, you may try <code class="language-plaintext highlighter-rouge">find-doc</code> instead, which takes a string or regular expression as argument: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (find-doc "ns-") ------------------------- clojure.core/ns-aliases ([ns]) Returns a map of the aliases for the namespace. ------------------------- clojure.core/ns-imports ([ns]) Returns a map of the import mappings for the namespace. ... etc. </code></pre></div></div> <h3 id="defining-documentation-for-your-own-functions">Defining documentation for your own functions</h3> So where does the documentation come from? Every definition of a function or macro or multimethod may take a description string before the arguments: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(defn area "Computes the area of a rectangle." [r] (* (.width r) (.height r))) </code></pre></div></div> … which the <code class="language-plaintext highlighter-rouge">doc</code> function prints, formatted: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (doc area) ------------------------- user/area ([r]) Computes the area of a rectangle. nil </code></pre></div></div> <h3 id="defining-documentation-for-a-variable">Defining documentation for a variable</h3> <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(def #^{:doc "The maximum number of connections"} max-con 10) </code></pre></div></div> … which the <code class="language-plaintext highlighter-rouge">doc</code> function prints as: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (doc max-con) ------------------------- user/max-con nil The maximum number of connections nil </code></pre></div></div> Function documentation is internally set like the above: <code class="language-plaintext highlighter-rouge">defn</code> is a macro that defines a function and puts the second argument as the doc string of the variable that points to the function body (among many other things). <h3 id="adding-a-test-function-to-a-variable">Adding a test function to a variable</h3> We first declare the variable, and then define it with a metadata map that includes a test function: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(declare a) (def #^{:test #(if (< a 10) (throw (Exception. "Value under 10!")))} a 6) </code></pre></div></div> … which we then test, by invoking the function <code class="language-plaintext highlighter-rouge">test</code> not on the value of the variable <code class="language-plaintext highlighter-rouge">a</code> (which could have its own metadata map), but on the variable <code class="language-plaintext highlighter-rouge">a</code> itself, referred to with the <code class="language-plaintext highlighter-rouge">#'a</code>: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(test #'a) </code></pre></div></div> The test results, in this case, in an exception being thrown: <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>java.lang.Exception: Value under 10! </code></pre></div></div> Otherwise, it would just return the <code class="language-plaintext highlighter-rouge">:ok</code> keyword. <h2 id="a-fibonacci-sequence-lazy-and-infinite-sequences">A fibonacci sequence: lazy and infinite sequences</h2> A beautiful example of using lazy sequences and applying functions to one or more sequences at a time. Below, the sequence <code class="language-plaintext highlighter-rouge">fibs</code> is defined in such a way that it contains all possible <a href="https://en.wikipedia.org/wiki/Fibonacci_number">fibonacci numbers</a>. Since such sequence is infinite, we declared it as <code class="language-plaintext highlighter-rouge">lazy</code> sequence, that creates new elements only when they are asked for. The <code class="language-plaintext highlighter-rouge">lazy-cat</code> clojure function creates such lazy sequence by concatenation of two sequences: the first sequence is <code class="language-plaintext highlighter-rouge">0, 1</code> (which takes the role of feeder or initialization sequence), and the second sequence is the result of a <code class="language-plaintext highlighter-rouge">map</code> operation over two subsets of the <code class="language-plaintext highlighter-rouge">fibs</code> sequence itself: the full and the full minus the first element (hence the <code class="language-plaintext highlighter-rouge">rest</code> operation to obtain the list of all elements without the first). A <code class="language-plaintext highlighter-rouge">map</code> operation applies a function to each element of a sequence, or, when two or more sequences are provided, to the corresponding elements: those at index 0 in all sequences, those at index 1 in all sequences, etc. To generate the fibonacci sequence of numbers, a sum <code class="language-plaintext highlighter-rouge">+</code> operation is mapped to the numbers contained in the self sequence <code class="language-plaintext highlighter-rouge">fibs</code> and to the corresponding elements of the self sequence <code class="language-plaintext highlighter-rouge">fibs</code> minus the first element, i.e. shifted by one. In short, the lazy sequence <code class="language-plaintext highlighter-rouge">fibs</code> is an abstract way of representing a potentially infinite sequence, with an implementation containing a full abstract definition of all fibonacci numbers. Then we just <code class="language-plaintext highlighter-rouge">take</code> the first 10 elements of such lazy sequence, which are created on the fly. <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(def fibs (lazy-cat [0 1] (map + fibs (rest fibs)))) (take 10 fibs) </code></pre></div></div> Which outputs: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(0 1 1 2 3 5 8 13 21 34) </code></pre></div></div> <h3 id="printing-lazy-sequences-to-the-repl">Printing lazy sequences to the REPL</h3> The REPL, when given a lazy sequence, will traverse it in its entirety to print it. Printing a potentially infinite lazy sequence to the REPL is something you don’t want to do: besides triggering computation of each element, it would fill all memory and throw an OutOfMemoryException. And you’d get bored seeing elements pass by. A good option is to print only part of it: <ul> <li><code class="language-plaintext highlighter-rouge">take</code>: the first N elements.</li> <li><code class="language-plaintext highlighter-rouge">drop</code>: all elements beyond N.</li> <li><code class="language-plaintext highlighter-rouge">nth</code>: the nth element only.</li> </ul> For infinite lazy sequences, <code class="language-plaintext highlighter-rouge">drop</code> wouldn’t save your REPL, and <code class="language-plaintext highlighter-rouge">take</code> could be perhaps too many still. To avoid accidental printing of complete lazy-sequences, you may set <code class="language-plaintext highlighter-rouge">*print-length*</code> to a reasonable number: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(set! *print-length* 5) </code></pre></div></div> So now one can safely print the entire fibonnaci sequence, which will print only the first 5 elements, followeed by dots: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (set! *print-length* 5) 5 user=> fibs (0 1 1 2 3 ...) </code></pre></div></div> The <code class="language-plaintext highlighter-rouge">*print-length*</code> applies to all sequences to be printed in the REPL, but is specially useful for very large lazy sequences. <h2 id="creating-shallow-and-deep-sequences-from-java-arrays">Creating shallow and deep sequences from java arrays</h2> Many clojure functions take sequences, not native java arrays, as arguments. A java native array can be wrapped by a shallow sequence like the following: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>>>> (def pixels (into-array (range 10))) #'user/pixels >>> pixels [Ljava.lang.Integer;@f30d8e >>> (def seq-pix (seq pixels)) #'user/seq-pix >>> seq-pix (0 1 2 3 4 5 6 7 8 9) </code></pre></div></div> Now if we modify the native array, the sequence will reflect that change too when read: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>>>> (aset pixels 3 99) 99 >>> seq-pix (0 1 2 99 4 5 6 7 8 9) </code></pre></div></div> The array was not duplicated. The only new object created was the shallow sequence: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>>>> (class seq-pix) clojure.lang.ArraySeq </code></pre></div></div> To create a true deep duplicate of the array, one can do: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>>>> (def pixels2 (vec pixels)) #'user/pixels2 >>> (class pixels2) clojure.lang.LazilyPersistentVector >>> pixels2 [0 1 2 99 4 5 6 7 8 9] >>> (def seq-pix2 (seq pixels2)) #'user/seq-pix2 >>> (class seq-pix2) clojure.lang.APersistentVector$Seq </code></pre></div></div> Or, in short: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(def seq-pix2 (seq (vec pixels))) #'user/seq-pix2 </code></pre></div></div> So now any changes to the original <code class="language-plaintext highlighter-rouge">pixels</code> array will not affect the new sequence: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>>>> (aset pixels 3 101) 101 >>> seq-pix2 (0 1 2 99 4 5 6 7 8 9) </code></pre></div></div> Thanks to Chouser and wwmorgan for examples on #clojure at irc.freenode.net <h2 id="generating-java-classes-from-clojure-code">Generating java classes from clojure code</h2> Using ahead of time (AOT) compilation with <a href="http://clojure.org/compilation">gen-class</a>, any clojure code can be compiled to a java class. Such class can then be used from java code, or from any scripting language like <a href="/scripting/jython">jython</a>, <a href="/scripting/jruby">jruby</a>, <a href="/scripting/javascript">javascript</a>, and <a href="/scripting">any other</a>. One way to do so is to place a <a href="http://clojure.org/compilation">gen-class</a> declaration in a namespace block. Be aware: the namespace must match the folder structure where the <code class="language-plaintext highlighter-rouge">.clj</code> file is and the file name of the <code class="language-plaintext highlighter-rouge">.clj</code> file. For example, to generate a class named <code class="language-plaintext highlighter-rouge">fj.tests.process.FloatProcessorPlus</code>, you need a clojure file under <code class="language-plaintext highlighter-rouge">fj/tests/process/FloatProcessorPlus.clj</code>. To compile the clojure code to <code class="language-plaintext highlighter-rouge">.class</code> files, you need: <ol> <li>A <code class="language-plaintext highlighter-rouge">classes/</code> folder in the current directory where <code class="language-plaintext highlighter-rouge">clojure.lang.Repl</code> is run. This folder will receive the generated <code class="language-plaintext highlighter-rouge">.class</code> files.</li> <li>Add to your classpath the top-level folder, in the example the ‘fj’ folder, and also the folder containing the .clj file itself.</li> <li>Add to your classpath the classes/ folder as well.</li> <li>In a clojure.lang.Repl, use the <code class="language-plaintext highlighter-rouge">compile</code> function.</li> </ol> For example: <div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code>$ mkdir classes $ java -cp .:../../ij.jar:../../jars/clojure.jar:./classes/:./fj/tests/process/ clojure.lang.Repl </code></pre></div></div> <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (compile 'fj.tests.process.FloatProcessorPlus) fj.tests.process.FloatProcessorPlus user=> </code></pre></div></div> The following clojure example contains a namespace declaration that includes some imports and also the gen-class. In the gen-class block, we define which class our code extends (in this case, ij.process.FloatProcessor), and which methods are to be created (with specific argument signatures and return object signature). Later, the compiler will assign a clojure function to each declared method, using the prefix string plus the method name to match a function. For example, with prefix <code class="language-plaintext highlighter-rouge">fp-</code> and method <code class="language-plaintext highlighter-rouge">fillValue</code>, the compiler will look for the clojure function <code class="language-plaintext highlighter-rouge">fp-fillValue</code>. Finally, a main method is not directly declared, but exists if a function named prefix + main (<code class="language-plaintext highlighter-rouge">fp-main</code> in the example) exists. We can use the main method to run the new class as an application. The example clojure code: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; Albert Cardona 20081203 ; Save this file as fj/tests/process/FloatProcessorPlus.clj ; and compile it from a Repl or clojure script like: ; ; (compile 'fj.tests.process.FloatProcessorPlus) ; ; Be sure to set the classpath to point to the folder containing the above file, for example: ; $ cd fiji/plugins/ ; $ mkdir -p tests/fj/tests/process ; $ cd tests/fj/tests/process/ ; $ vim FloatProcessorPlus.clj ; ... ; $ cd ../../../ ; $ mkdir classes ; $ java -cp ../../ij.jar:../../jars/clojure.jar:./classes/:.:./fj/tests/process/ clojure.lang.Repl ; user=> (compile 'fj.tests.process.FloatProcessorPlus) ; fj.tests.process.FloatProcessorPlus ; user=> ; ; The compilation will place the proper `.class` files under the proper directory ; structure in the ./classes/ folder. ; ; Then run like any other java class with a static public void main method: ; $ java -cp .:../../ij.jar:../../jars/clojure.jar:./classes fj.tests.process.FloatProcessorPlus ; (ns fj.tests.process.FloatProcessorPlus (:import (ij ImagePlus) (ij.process FloatProcessor) (java.util Random)) (:gen-class ; Could also use :implements :extends ij.process.FloatProcessor ; Specify methods to expose as public, ; with specific parameter types and return type: :methods [[fillMin [] void] [fillMax [] void] [fillValue [float] void] [randomize [] void]] ; Define a function prefix for the exposed methods: for example, ; the fillMin public method is implemented by function fp-fillMin. :prefix "fp-")) (defn fp-fillValue [this value] "Set each pixel in the image to the given value." (.setPixels this (into-array Float/TYPE (replicate (* (.getWidth this) (.getHeight this)) (float value))))) (defn fp-fillMin [this] (.fillValue this Float/MIN_VALUE)) (defn fp-fillMax [this] (.fillValue this Float/MAX_VALUE)) ; Declaring a function to be used as a java method, within a closure: (let [generator (Random. (System/currentTimeMillis))] (defn fp-randomize [this] (.setPixels this (into-array Float/TYPE (map (fn [x] (.nextFloat generator)) (range (* (.getWidth this) (.getHeight this)))))))) ; This function is seen as the static public void main function of a java class: ; (add a parameter, like [args], if you would like to access the command-line args) (defn fp-main [] "Test the generated class" (let [imp (ImagePlus. "Test" (fj.tests.process.FloatProcessorPlus. 100 100)) ip (.getProcessor imp)] ; Testing access on "ImageProcessor" type (.show imp) ; Test some methods of our extended FloatProcessor class: (.randomize ip) (.findMinAndMax ip) (.updateAndDraw imp))) </code></pre></div></div> <h2 id="references-concurrency-transactions-and-synchronization">References, concurrency, transactions and synchronization</h2> Clojure supports thread concurrency without explicit locks. Compared to java code, this is a gigantic step forward: locks, and particularly multiple locks, are very hard to get right and very, very hard to debug properly (but see <a href="http://albert.rierol.net/java_tricks.html#How%20to%20debug%20a%20multithreaded%20java%20program">debugging multithreaded java programs</a>). The most basic building blocks are <a href="http://clojure.org/refs">references</a>, which are created with the <code class="language-plaintext highlighter-rouge">ref</code> function, and modified within transaction blocks (defined by <code class="language-plaintext highlighter-rouge">dosync</code>) using <code class="language-plaintext highlighter-rouge">commute</code> or <code class="language-plaintext highlighter-rouge">alter</code> functions (and <a href="http://clojure.org/refs">others</a>). To read out the value of a reference, call <code class="language-plaintext highlighter-rouge">deref</code> or just <code class="language-plaintext highlighter-rouge">@</code> on it: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; Create a new reference named 'id' initializated to value zero: (def id (ref 0)) -> 0 ; Read out the value of the reference: @id -> 0 ; Increase the id by one, using built-in function "inc": (dosync (alter id inc)) -> 1 ; Set the value to 20 (ignoring the current value, given in cv: (dosync (alter id (fn [cv] 20))) -> 20 </code></pre></div></div> References are not type specific: any object may be assigned to the same reference. Whether that makes any sense is up to you. The <code class="language-plaintext highlighter-rouge">commute</code> and <code class="language-plaintext highlighter-rouge">alter</code> functions replace the value of the reference with that of the return value of a function given as argument. The function given as argument to <code class="language-plaintext highlighter-rouge">commute</code> and <code class="language-plaintext highlighter-rouge">alter</code> is given, in turn, the value of the reference (i.e. the dereferenced reference) and any other further arguments. The difference between <code class="language-plaintext highlighter-rouge">commute</code> and <code class="language-plaintext highlighter-rouge">alter</code> is that <code class="language-plaintext highlighter-rouge">commute</code> returns the dereferenced reference after the transaction is done, which may be different already (because of concurrent modifications) than the value that was set to the reference within the transaction; whereas <code class="language-plaintext highlighter-rouge">alter</code> returns the value that it had while the transaction was being done (i.e. the value returned by the function, the same that gets set as the value of the reference). In the following example, a unique id counter is incremented continuously by 1, and all ids are collected, unordered, into a vector. Both the next available id and the vector of all accessed ids are stored in references. Keep in mind the vector of ids assigned to the reference named ‘ls’ is always immutable: what we assign to the reference ‘ls’ below is a new vector, resulting from adding a new id to the old vector of ids. This immutability enables other threads to read the vector without locks. For performance, keep in mind that vectors, like many other clojure data structures, have structural sharing, so the new vector is not a duplication–even if it behaves like one. The assignment is done in a transaction, so no matter how many concurrent threads try to do so, the resulting vector will have all the ids. <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; Albert Cardona 2008-12-18 ; Example clojure program using references and concurrent threads ; that alter the value of the references. ; ; 10 threads running concurrently ; each thread runs 100000 iterations ; in each iteration the thread increments a counter 'id' ; and adds it to a list 'ls' of ids. ; At the end, we print the current value of 'id' ; and the length of the list 'ls' of ids. ; ; No locks! (ns fj.test.concurrent (:import (java.util.concurrent Executors TimeUnit))) (let [ls (ref []) ; A reference to a vector storing a list if ids. id (ref 0) ; The next unique id available. n_threads 10 n_iterations 100000 exec (Executors/newFixedThreadPool n_threads)] (println "Running" n_threads "threads x" n_iterations "iterations/thread...") (dotimes [i n_threads] (.submit exec (fn [] (dotimes [t n_iterations] ; Obtain the next unique id: ; (Note we use "alter" and not "commute", because alter ; returns the result of the applied function, whereas ; commute would return the dereferenced ref, which could ; have already changed. Thanks to AWizzards for spotting ; this.) (let [next-id (dosync (alter id inc))] ; Create a new vector made of ; all previous ids and next-id, ; and set it as the current list of ids: (dosync (commute ls conj next-id))))) nil)) (.shutdown exec) (.awaitTermination exec 10 TimeUnit/MINUTES) (println "... done!") ; If there was any clash in setting the reference to the list of ids, ; the count would be less than 1000000: (println "Number of listed ids:" (count @ls)) ; If any id was used twice, the next available id would be less than 1000000: (println "Next available id:" @id) ; Check that there aren't any repeated ids: (println "Number of repeated ids:" (- (count @ls) (count (set @ls))))) ; Make a hash set (with unique entries) from the list of ids </code></pre></div></div> <h2 id="using-trycatchfinally-and-throwing-exceptions">Using try/catch/finally and throwing Exceptions</h2> <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(try (println "Going to throw ...") (throw (Exception. "Testing error catching")) (println "Should not print, an Exception is thrown before") (catch Exception e (println "Oops ... an error ocurred.") (.printStackTrace e)) (finally (println "Cleaning up!"))) </code></pre></div></div> Of course you can throw any kind of exception you want. For example, in checking function arguments: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(import '(java.awt Rectangle)) (defn area [#^Rectangle r] (if (not (instance? Rectangle r)) (throw (IllegalArgumentException. "Can only compute the area of a Rectangle."))) (* (.width r) (.height r))) </code></pre></div></div> Above, despite the type declaration, one can pass any value to the <code class="language-plaintext highlighter-rouge">area</code> function and it will still work, but of course our class check will cut execution: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (area 10) java.lang.IllegalArgumentException: Can only compute the area of a Rectangle. (NO_SOURCE_FILE:0) </code></pre></div></div> <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (area (Rectangle. 0 0 10 10)) 100 </code></pre></div></div> <h2 id="executing-a-command-in-a-shell-and-capturing-its-output">Executing a command in a shell and capturing its output</h2> First we define the macro <code class="language-plaintext highlighter-rouge">exec</code>: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(import '(java.io BufferedReader InputStreamReader)) (defmacro exec "Execute a command on the shell, passing to the given function the lazy sequence of lines read as output, and the rest of arguments." [cmd pred & args] `(with-open [br# (BufferedReader. (InputStreamReader. (.getInputStream (.exec (Runtime/getRuntime) ~cmd))))] (~pred (line-seq br#) ~@args))) </code></pre></div></div> Some explanations on the above macro syntax (see also <a href="http://clojure.org/macros">clojure’s macro syntax page</a>): <ul> <li>The backquote ` quotes the next expression, as defined by: `( <any code="" here=""> ). Which means the code block is *not* evaluated. But, unlike simple quote ', the backquote enables evaluation of expressions within the block when tagged with a \~ (a tilde).</any></li> <li>The ~ (tilde) evaluates the immediate expression. Can only be used in the context of a backquoted code block.</li> <li>The ~@ means evaluate and expand, which has the efect of placing the elements of a list as if they where declared in the code, without the list enclosure. So: `(~@(str “this” “that”)) results in: “thisthat”. In the example above, we expand the <code class="language-plaintext highlighter-rouge">& args</code>, which is a list containing all arguments given to the exec macro beyond the first and second (which are bound to <code class="language-plaintext highlighter-rouge">cmd</code> and <code class="language-plaintext highlighter-rouge">pred</code>, respectively). In this way, we lay down the proper function call of the <code class="language-plaintext highlighter-rouge">pred</code>, which is expected to be a function name (a predicate); the reason we use ~ on it is to evaluate <code class="language-plaintext highlighter-rouge">pred</code> so that it renders the pointer to the function itself. That <code class="language-plaintext highlighter-rouge">pred</code> function, by design, must accept a lazy sequence of text lines and any number of arguments afterwards.</li> <li>The # tagged at the end of a name expands to (gensym name), which results in creating a uniquely named symbol, to avoid name collisions.</li> <li>Any code present outside the backquote (none, in the case above) will be executed at macro read time, not at code execution time (aka run time)! So any precomputations are possible before laying down the code that will be executed at run time.</li> </ul> Then we give the macro a command to execute and a function to process its stdout output. <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; List all files in the home directory: (exec "ls /home/albert/" #(doseq [line %1] (println line))) </code></pre></div></div> A second example, printing the file size of each listed file in the home directory: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>; Print the size of each file in the home directory: (import '(java.io File)) (let [dir "/home/albert/"] (exec (str "ls " dir) #(doseq [line %1] (println (.length (File. (str dir line))))))) </code></pre></div></div> A third example, telling the music player XMMS2 to jump to a specific track in its playlist: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [track-number 125] (exec (str "xmms2 jump " track-number) (fn [lines] lines))) </code></pre></div></div> The above is an extract from a clojure GUI for XMMS2, available at github <a href="https://github.com/acardona/xmms2-clj/">xmms2-gui</a>. <h2 id="creating-a-derivative-of-a-function">Creating a derivative of a function</h2> The derivative of a function: \[D f(x) = f'(x) = \lim_{dx\rightarrow 0}\frac{f(x + dx) - f(x)}{dx}\] We can approximate the derivative by choosing an arbitrarily precise value of the increment <code class="language-plaintext highlighter-rouge">dx</code>. So first we define a function that takes any function as argument and returns a new function that implements its derivative. For convenience, we define it within a closure that specifies the arbitrarily precise increment <code class="language-plaintext highlighter-rouge">dx</code> (but we could just pass it as argument): <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(let [dx (double 0.0001)] (defn derivative [f] "Return a function that is the derivative of the given function f, using dx increments." (fn [x] (/ (- (f (+ (double x) dx)) (f x)) dx)))) </code></pre></div></div> Then, for any example function like the cube of x: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(defn cubic [x] (let [a (double x)] (* a a a))) </code></pre></div></div> … we create its derivative function, which we place into a variable (note we use <code class="language-plaintext highlighter-rouge">def</code> and not <code class="language-plaintext highlighter-rouge">defn</code>): <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(def cubic-prime (derivative cubic)) </code></pre></div></div> We can now call the cubic-prime function simply like any other function: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(cubic-prime 2) -> 12.000600010022566 </code></pre></div></div> <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(cubic-prime 3) -> 27.00090001006572 (cubic-prime 4) -> 48.00120000993502 </code></pre></div></div> The derivative of x^3 is 3 * x^2, which for an x of 4 equals 48. Our derivative is as precise as low is the value of the increment <code class="language-plaintext highlighter-rouge">dx</code>. The above code translated from lisp code at <a href="http://funcall.blogspot.com/2009/03/not-lisp-again.html">funcall blog</a>. Thanks <a href="http://www.blogger.com/profile/03233353484280456977">Joe Marshall</a> for sharing this perl. <h2 id="pretty-printing-a-primitive-array">Pretty printing a primitive array</h2> Suppose we create a primitive array of length 10: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (def pa (make-array Integer/TYPE 10)) </code></pre></div></div> If we print it, we get: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (println pa) #<int[] [I@169bc15> </code></pre></div></div> … which is not very useful. Instead, let’s pretty print it. First, import the function <code class="language-plaintext highlighter-rouge">pprint</code> (and many other functions) from clojure-contrib pprint namespace: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (use 'clojure.contrib.pprint) </code></pre></div></div> Then, use it: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (pprint pa) [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] </code></pre></div></div> A similar result can be obtained by wrapping primitive arrays with <code class="language-plaintext highlighter-rouge">seq</code>, which generates a Collection view on the primitive array: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (println (seq pa)) [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] </code></pre></div></div> That <code class="language-plaintext highlighter-rouge">seq</code> creates only a view (and not a copy), you can convince yourself: changing the array changes the view, too: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>user=> (def sa (seq pa)) user=> sa [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] user=> (aset pa 3 7) user=> (pprint pa) [0, 0, 0, 7, 0, 0, 0, 0, 0, 0] user=> sa [0, 0, 0, 7, 0, 0, 0, 0, 0, 0] </code></pre></div></div> <h2 id="loading-an-image-file-into-a-byte-array">Loading an image file into a byte array</h2> <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(import [java.io File FileInputStream] (defn ^bytes load-file "Load a file into a byte array." [filepath] (let [^File f (File. filepath) len (int (.length f)) ^bytes b (byte-array len)] (with-open [^FileInputStream fis (FileInputStream. f)] (loop [offset (int 0)] (if (< offset len) (recur (unchecked-add offset (.read fis b offset (unchecked-subtract len offset))))))) b)) </code></pre></div></div> … which then may be parsed as a <code class="language-plaintext highlighter-rouge">java.awt.Image</code>: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(def img (javax.imageioImageIO/read (java.io.ByteArrayInputStream. (load-file "/home/acardona/Desktop/t2/NileBend.jpg")))) </code></pre></div></div> … which then may be shown as an <code class="language-plaintext highlighter-rouge">ImagePlus</code>: <div class="language-clojure highlighter-rouge"><div class="highlight"><pre class="highlight"><code>(.show (ij.ImagePlus. "nile bend" img)) </code></pre></div></div> </div> </div> </section>  <section id="footer"> <ul class="icons"> <li><a href="https://forum.image.sc/tag/imagej" class="icon alt"><img src="/media/icons/image-sc.png" width="24" style="vertical-align: middle; margin-top: -10px">Forum</a></li> <li><a href="https://twitter.com/hashtag/ImageJ" class="icon brands alt fa-twitter">Twitter</a></li> <li><a href="https://github.com/imagej" class="icon brands alt fa-github">GitHub</a></li> </ul> <ul class="copyright"> <li>Design: <a href="http://html5up.net">HTML5 UP</a></li> </ul> </section>  <nav role="navigation"> <div id="ham-toggle"> <input type="checkbox" />    <ul id="ham-menu"> <div class="menu"><h3>ImageJ Docs</h3> <ul> <li><a href="/downloads">Download</a></li> <li><details><summary>Learn</summary><ul> <li><details><summary><a href="/learn">ImageJ Basics</a></summary><ul> <li><a href="/tutorials">Tutorials</a></li> <li><a href="/learn/user-guides">User Guides</a></li> <li><a href="/learn/keyboard-shortcuts">Keyboard Shortcuts</a></li> <li><a href="/learn/tips-and-tricks">Tips and Tricks</a></li> <li><a href="/learn/troubleshooting">Troubleshooting</a></li> <li><a href="/learn/faq">Frequently Asked Questions</a></li> <li><details><summary><a href="/platforms">Supported Platforms</a></summary><ul> <li><a href="/platforms/windows">Windows</a></li> <li><a href="/platforms/macos">MacOS</a></li> <li><a href="/platforms/linux">Linux</a></li> <li><a href="/platforms/pi">Raspberry Pi</a></li> <li><a href="/platforms/android">Android</a></li> </ul></details></li>  <li><details><summary><a href="/formats">File Formats</a></summary><ul> <li><a href="/formats/bio-formats">Bio-Formats</a></li> <li><a href="/formats/video">Video formats</a></li> <li><a href="/formats/quicktime">QuickTime</a></li> <li><a href="/formats/tiff">TIFF</a></li> <li><a href="/formats/pdf">PDF</a></li> <li><a href="/formats/dicom">DICOM</a></li> <li><a href="/formats/lsm">Zeiss LSM</a></li> <li><a href="/formats/olympus">Olympus VSI</a></li> <li><a href="/formats/lurawave">Opera Flex</a></li> <li><a href="/formats/fib-sem">FIB-SEM</a></li> </ul></details></li>  </ul></details></li>  <li><details><summary><a href="/imaging">Scientific Imaging</a></summary><ul> <li><a href="/imaging/principles">Principles of Scientific Imaging</a></li> <li><a href="/imaging/annotating-images">Annotating Images</a></li> <li><a href="/imaging/colocalization-analysis">Colocalization</a></li> <li><a href="/imaging/color-image-processing">Color Image Processing</a></li> <li><a href="/imaging/deconvolution">Deconvolution</a></li> <li><a href="/imaging/image-intensity-processing">Image Intensity Processing</a></li> <li><a href="/imaging/particle-analysis">Particle Analysis</a></li> <li><a href="/imaging/registration">Registration</a></li> <li><a href="/imaging/segmentation">Segmentation</a></li> <li><a href="/imaging/stack-slice-manipulations">Stack-slice Manipulations</a></li> <li><a href="/imaging/t-functions">T-functions</a></li> <li><a href="/imaging/tracking">Tracking</a></li> <li><a href="/imaging/visualization">Visualization</a></li> <li><a href="/imaging/z-functions">Z-functions</a></li> </ul></details></li>  </ul></details></li>  <li><details open><summary><a href="/plugins">Extend</a></summary><ul> <li><a href="/list-of-extensions">List of Extensions</a></li> <li><details><summary><a href="/update-sites">Update Sites</a></summary><ul> <li><a href="/list-of-update-sites">List of Update Sites</a></li> <li><a href="/update-sites/following">Following an Update Site</a></li> <li><a href="/update-sites/setup">Creating an Update Site</a></li> <li><a href="/update-sites/tos">Terms of Service</a></li> <li><a href="/update-sites/automatic-uploads">Automatic Upload</a></li> <li><a href="/update-sites/core-uploads">Uploading to Core Sites</a></li> <li><a href="/update-sites/faq">Update Sites FAQ</a></li> <li><a href="/update-sites/stats">Statistics</a></li> </ul></details></li>  <li><details open><summary><a href="/scripting">Scripting</a></summary><ul> <li><a href="/scripting/basics">Scripting Basics</a></li> <li><a href="/scripting/script-editor">Script Editor</a></li> <li><a href="/scripting/parameters">Parameters</a></li> <li><a href="/scripting/user-input">User Input</a></li> <li><a href="/scripting/auto-imports">Auto Import</a></li> <li><a href="/scripting/templates">Templates</a></li> <li><a href="/scripting/batch">Batch Processing</a></li> <li><a href="/scripting/headless">Running Headlessly</a></li> <li><a href="/scripting/comparisons">Scripting Comparisons</a></li> <li><a href="/scripting/toolbox">Toolbox</a></li> <li><details open><summary>Languages</summary><ul> <li><a href="/scripting/beanshell">BeanShell Scripting</a></li> <li><a href="/scripting/groovy">Groovy Scripting</a></li> <li><a href="/scripting/macro">ImageJ Macro</a></li> <li><a href="/scripting/javascript">JavaScript</a></li> <li><a class="current-page">Lisp (Clojure)</a></li> <li><a href="/scripting/matlab">MATLAB</a></li> <li><a href="/scripting/jython">Python (Jython)</a></li> <li><a href="/scripting/python">Python (native)</a></li> <li><a href="/scripting/renjin">R (Renjin)</a></li> <li><a href="/scripting/jruby">Ruby (JRuby)</a></li> <li><a href="/scripting/scala">Scala Scripting</a></li> </ul></details></li>  </ul></details></li>  <li><details><summary><a href="/develop">Development</a></summary><ul> <li><a href="/develop/philosophy">Philosophy</a></li> <li><a href="/develop/architecture">Architecture</a></li> <li><a href="/develop/source">Source code</a></li> <li><a href="/develop/project-management">Project management</a></li> <li><a href="/develop/coding-style">Coding style</a></li> <li><a href="/develop/javadoc">Using Javadoc</a></li> <li><a href="/develop/debugging">Debugging</a></li> <li><a href="/develop/wish-list">Wish list</a></li> <li><details><summary>Tools</summary><ul> <li><a href="/develop/github">GitHub</a></li> <li><a href="/develop/maven">Maven</a></li> <li><a href="/develop/ci">CI/CD</a></li> <li><a href="/develop/dotfiles">Dotfiles</a></li> <li><details><summary><a href="/develop/ides">IDEs</a></summary><ul> <li><a href="/develop/eclipse">Eclipse</a></li> <li><a href="/develop/netbeans">NetBeans</a></li> <li><a href="/develop/intellij">IntelliJ IDEA</a></li> <li><a href="/develop/command-line">Command Line</a></li> </ul></details></li> </ul></details></li>  <li><details><summary>Guides</summary><ul> <li><a href="/develop/plugins">Writing plugins</a></li> <li><a href="/develop/improving-the-code">Contributing to a plugin</a></li> <li><a href="/develop/releasing">Development lifecycle</a></li> <li><a href="/develop/building-a-pom">Building a POM</a></li> <li><a href="/develop/debugging-exercises">Hands-on debugging</a></li> <li><a href="/develop/writing-ops">Adding new ops</a></li> <li><a href="/develop/formats">Adding new formats</a></li> <li><a href="/develop/native-libraries">Using native libraries</a></li> <li><a href="/develop/tips">Tips for developers</a></li> <li><a href="/develop/cpp-tips">Tips for C++ developers</a></li> <li><a href="/develop/ij1-plugins">ImageJ 1.x plugins</a></li> <li><a href="/develop/versioning">Versioning</a></li> <li><a href="/develop/logging">Logging</a></li> <li><a href="/develop/uber-jars">Uber-JARs</a></li> </ul></details></li>  <li><details><summary><a href="/develop/git">Git</a></summary><ul> <li><a href="/develop/git/eclipse">Git in Eclipse (EGit)</a></li> <li><a href="/develop/git/mini-howto">Git mini howto</a></li> <li><a href="/develop/git/workshop">Git workshop</a></li> <li><a href="/develop/git/conflicts">Git conflicts</a></li> <li><a href="/develop/git/topic-branches">Git topic branches</a></li> <li><a href="/develop/git/notes">Git notes</a></li> <li><a href="/develop/git/reflogs">Git reflogs</a></li> <li><a href="/develop/git/submodules">Git submodules</a></li> <li><a href="/develop/git/pinpoint-regressions">How to pinpoint regressions</a></li> <li><a href="/develop/git/publish-a-repository">How to publish a git repository</a></li> <li><a href="/develop/git/extract-a-subproject">How to extract a subproject</a></li> </ul></details></li>  </ul></details></li>  </ul></details></li>  <li><details><summary><a href="/contribute">Contribute</a></summary><ul> <li><a href="/contribute/citing">Citing</a></li> <li><a href="/people">Contributors</a></li> <li><a href="/orgs">Organizations</a></li> <li><a href="/contribute/governance">Governance</a></li> <li><a href="/contribute/funding">Funding</a></li> <li><a href="/contribute/fiji">Contributing to Fiji</a></li> <li><details><summary><a href="/licensing">Licensing</a></summary><ul> <li><details><summary><a href="/licensing/open-source">Open Source</a></summary><ul> <li><a href="/licensing/apache">Apache</a></li> <li><a href="/licensing/bsd">BSD</a></li> <li><a href="/licensing/epl">EPL</a></li> <li><a href="/licensing/gpl">GPL</a></li> <li><a href="/licensing/lgpl">LGPL</a></li> <li><a href="/licensing/mit">MIT</a></li> <li><a href="/licensing/public-domain">Public domain</a></li> <li><a href="/licensing/big">BIG</a></li> </ul></details></li>  <li><a href="/licensing/closed-source">Proprietary</a></li> </ul></details></li>  <li><details><summary><a href="/editing">Editing the Wiki</a></summary><ul> <li><a href="/editing/advanced">Advanced Editing</a></li> <li><a href="/editing/buttons">Buttons</a></li> <li><a href="/editing/citations">Citations</a></li> <li><a href="/editing/code">Source Code</a></li> <li><a href="/editing/debugging">Debugging</a></li> <li><a href="/editing/headers">Headers</a></li> <li><a href="/editing/icons">Icons</a></li> <li><a href="/editing/images">Images</a></li> <li><a href="/editing/keys">Keyboard Shortcuts</a></li> <li><a href="/editing/linking">Linking</a></li> <li><a href="/editing/math">Math Expressions</a></li> <li><a href="/editing/menu-paths">Menu Paths</a></li> <li><a href="/editing/navigation">Navigation</a></li> <li><a href="/editing/notices">Notices</a></li> <li><a href="/editing/people">People</a></li> <li><a href="/editing/pitfalls">Pitfalls</a></li> <li><a href="/editing/quizzes">Quizzes</a></li> <li><a href="/editing/statbox">Statbox</a></li> <li><a href="/editing/symbols">Symbols</a></li> <li><a href="/editing/tables">Tables</a></li> <li><a href="/editing/timelines">Timelines</a></li> <li><a href="/editing/tooltips">Tooltips</a></li> <li><a href="/editing/videos">Videos</a></li> <li><a href="/editing/whitespace">Whitespace</a></li> </ul></details></li>  </ul></details></li>  <li><details><summary><a href="/discuss">Discuss</a></summary><ul> <li><a href="/discuss/bugs">Reporting Issues</a></li> <li><a href="/discuss/mailing-lists">Mailing Lists</a></li> <li><a href="/discuss/chat">Chat</a></li> </ul></details></li>  <li><details><summary>Explore</summary><ul> <li><a href="/news">News</a></li> <li><details><summary><a href="/events">Events</a></summary><ul> <li><a href="/events/presentations">Presentations</a></li> <li><a href="/events/conferences">Conferences</a></li> <li><a href="/events/hackathons">Hackathons</a></li> <li><a href="/events">More...</a></li> </ul></details></li>  <li><details><summary><a href="/libs">Libraries</a></summary><ul> <li><a href="/libs/imagej-ops">ImageJ Ops</a></li> <li><a href="/libs/imagej-common">ImageJ Common</a></li> <li><a href="/libs/imagej-legacy">ImageJ Legacy</a></li> <li><a href="/libs/scijava">SciJava</a></li> <li><a href="/libs/scifio">SCIFIO</a></li> <li><details><summary><a href="/libs/imglib2">ImgLib2</a></summary><ul> <li><a href="/libs/imglib2/getting-started">Getting Started</a></li> <li><a href="/libs/imglib2/accessors">Accessors</a></li> <li><a href="/libs/imglib2/accessibles">Accessibles</a></li> <li><a href="/libs/imglib2/examples">Examples</a></li> <li><a href="/libs/imglib2/workshop-introductory">Introductory Workshop</a></li> <li><a href="/libs/imglib2/workshop-advanced">Advanced Workshop</a></li> <li><a href="/libs/imglib2/matlab">ImgLib2 images in MATLAB</a></li> <li><a href="/libs/imglib2/benchmarks">Benchmarks</a></li> <li><a href="/libs/imglib2/faq">FAQ</a></li> <li><a href="/libs/imglib2/developing">Developing ImgLib2</a></li> <li><a href="/libs/imglib2/discussion">ImgLib2 Discussion</a></li> </ul></details></li>  <li><a href="/libs">More...</a></li> </ul></details></li>  <li><details><summary><a href="/software">Software</a></summary><ul> <li><a href="/software/nih-image">NIH Image</a></li> <li><a href="/software/imagej">ImageJ</a></li> <li><a href="/software/imagej2">ImageJ2</a></li> <li><a href="/software/fiji">Fiji</a></li> <li><a href="/software">More...</a></li> </ul></details></li>  </ul></details></li>  </ul> </div> </ul> </div> </nav> <div id="dock-overlay-left" class="dock-overlay" data-dock-target="left-column"></div> <div id="dock-overlay-right" class="dock-overlay" data-dock-target="right-column"></div>  <div id="search-results"> <div id="search-hits"></div> <div id="pagination"></div> </div>   <script src="/assets/js/jquery.min.js"></script> <script src="/assets/js/jquery.scrolly.min.js"></script> <script src="/assets/js/browser.min.js"></script> <script src="/assets/js/breakpoints.min.js"></script> <script src="/assets/js/util.js"></script> <script src="/assets/js/jquery.toc.js"></script> <script src="/assets/js/lightbox.min.js"></script>  <script type="text/javascript" async src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/MathJax.js?config=default"> </script>  <script src="/assets/js/main.js"></script> <script src="/assets/js/dock.js"></script> <script src="/assets/js/code.js"></script>  <script src="https://cdn.jsdelivr.net/npm/anchor-js/anchor.min.js"></script> <script>anchors.add('#page h1, #page h2, #page h3, #page h4, #page h5, #page h6');</script>  <script src="https://cdn.jsdelivr.net/npm/citation-js@0.4.0-9"></script> <script src="/assets/js/cite.js"></script>  <script src="https://cdn.jsdelivr.net/npm/algoliasearch@4.13.0/dist/algoliasearch-lite.umd.js"></script> <script src="https://cdn.jsdelivr.net/npm/instantsearch.js@4.40.3/dist/instantsearch.production.min.js"></script> <script src="/assets/js/search.js"></script> <script src="/assets/js/search-tweaks.js"></script> </body> </html>