>>> p = Display.getFront().getActive()
>>> print p
    090504_0314_ex0768.mrc z=0.0 #67398

>>> p = Display.getFront().getActive()
>>> imp = p.getImagePlus()
>>> print imp.width, imp.height
    2048 2048

>>> front = Display.getFront()
>>> layer = front.getLayer()
>>> layer_set = front.getLayerSet()
>>> sel = front.getSelection()
>>> print sel.getSelected().size()
    10
    >>> print sel.isEmpty()
    0

for d in Display.getFront().getSelected():
  d.setLocked(True)

for d in Display.getSelected(Patch):
  print d.title

front = Display.getFront()
selection = front.getSelection()
for d in selection.get(Patch):
  print d.title

regularExpression = ".*fold.*"

for layer in Display.getFront().getLayerSet().getLayers():
  for label in layer.getDisplayables(DLabel):
    if label.getTitle().matches(regularExpression):
      tx = label.getAffineTransform().getTranslationX()
      ty = label.getAffineTransform().getTranslationY()
      patches = layer.find(Patch, tx, ty)
      for patch in patches:
        print patch.getImageFilePath()

>>> p = Display.getFront().getActive()
>>> print p.title
    090504_0314_ex0768.mrc

>>> p = Display.getFront().getActive()
>>> p.title = "A new name for this Patch"
>>> print p.title
A new name for this Patch

>>> p = Display.getFront().getActive()
>>> p.title = "Test image"
>>> p.alpha = 0.4
>>> p.visible = True
>>> p.locked = False
>>> from java.awt import Color
>>> p.color = Color.blue

>>> Display.repaint()

>>> p.getAffineTransform()
AffineTransform[[1.0, 0.0, 474.0], [0.0, 1.0, 567.0]]
>>> print p.getBoundingBox()
java.awt.Rectangle[x=474,y=567,width=2048,height=2048]

>>> from java.awt.geom import AffineTransform
>>> aff = AffineTransform()
>>> aff.scale(2.0, 2.0)
>>> p.setAffineTransform(aff)
>>> p.updateBucket()

>>> from java.awt.geom import AffineTransform
>>> aff = AffineTransform()
>>> aff.translate(300, -400)
>>> p.preTransform(aff, True)

# Albert Cardona 2011-06-05
# Script for Colenso Speer

import os, re

#folder = "/path/to/folder/with/all/images/"
folder = "/home/albert/Desktop/t2/example-data/images/2043_5_6_7"

# 1. Create a TrakEM2 project
project = Project.newFSProject("blank", None, folder)
# OR: get the first open project
# project = Project.getProjects().get(0)

layerset = project.getRootLayerSet()

#  2. Create 10 layers (or as many as you need)
for i in range(10):
  layerset.getLayer(i, 1, True)

# ... and update the LayerTree:
project.getLayerTree().updateList(layerset)
# ... and the display slider
Display.updateLayerScroller(layerset)

# 3. To each layer, add images that have "_zN_" in the name
#     where N is the index of the layer
#     and also end with ".tif"
filenames = os.listdir(folder)
for i,layer in enumerate(layerset.getLayers()):
  # EDIT the following pattern to match the filename of the images
  # that must be inserted into section at index i:
  pattern = re.compile(".*_z" + str(i) + "_.*\.tif")
  for filename in filter(pattern.match, filenames):
    filepath = os.path.join(folder, filename)
    patch = Patch.createPatch(project, filepath)
    layer.add(patch)
  # Update internal quadtree of the layer
  layer.recreateBuckets()

# 4. Montage each layer independently
from mpicbg.trakem2.align import Align, AlignTask
param = Align.ParamOptimize()  # which extends Align.Param
param.sift.maxOctaveSize = 512
#  ... above, adjust other parameters as necessary
# See:
#    features: https://fiji.sc/javadoc/mpicbg/trakem2/align/Align.Param.html
#    transformation models: https://fiji.sc/javadoc/mpicbg/trakem2/align/Align.ParamOptimize.html
#    sift: https://fiji.sc/javadoc/mpicbg/imagefeatures/FloatArray2DSIFT.Param.html
AlignTask.montageLayers(param, layerset.getLayers(), False, False, False, False)

# 5. Resize width and height of the world to fit the montages
layerset.setMinimumDimensions()

# 6. Blend images of each layer
Blending.blendLayerWise(layerset.getLayers(), True, None)

# 7. Save the project
project.saveAs(os.path.join(folder, "montages.xml"), False)

print "Done!"

layer = Display.getFront().getLayer()

# Get all selected images
# patches = Display.getFront().getSelection().getSelected(Patch)

# Get all images in the current layer
patches = layer.getDisplayables(Patch)

for patch in patches:
  bounds = patch.getBoundingBox()
  patch.getAffineTransform().setToIdentity()
  patch.translate(bounds.x, bounds.y, False)

Display.repaint()

patch.updateBucket()

from ini.trakem2 import Project
from ini.trakem2.utils import AreaUtils
from ini.trakem2.display import AreaList
from java.awt import Color

# Obtain an image stack
#imp = IJ.getImage()
imp = WindowManager.getImage("0_5_filtered.tif")

# Obtain the opened TrakEM2 project
p = Project.getProjects()[0]

# Obtain the LayerSet
layerset = p.getRootLayerSet()

# Create a new AreaList, named "synapses"
ali = AreaList(p, "synapses", 0, 0)

# Add the AreaList to the datastructures:
layerset.add(ali)
p.getProjectTree().insertSegmentations([ali])

# Obtain the image stack
stack = imp.getImageStack()

# Iterate every slice of the stack
for i in range(1, imp.getNSlices() +1):
  ip = stack.getProcessor(i) # 1-based
  # Extract all areas (except background) into a map of value vs. java.awt.geom.Area
  m = AreaUtils.extractAreas(ip)
  # Report progress
  print i, ":", len(m)
  # Get the Layer instance at the corresponding index
  layer = layerset.getLayers().get(i-1) # 0-based
  # Add the first Area instance to the AreaList at the proper Layer
  ali.addArea(layer.getId(), m.values().iterator().next())

# Change the color of the AreaList
ali.setColor(Color.magenta)

# Ensure bounds are as constrained as possible
ali.calculateBoundingBox(None)

Display.repaint()

# Albert Cardona 2012-06-19
# Obtain an arealist and add all its areas as ROIs in the ROI Manager

from ini.trakem2.display import Display, AreaList
from ij.gui import ShapeRoi
from ij.plugin.frame import RoiManager

def getRoiManager():
  ** Obtain a valid instance of the ROI Manager.
  Notice that it could still be null if its window is closed.**
  if RoiManager.getInstance() is None:
    RoiManager()
  return RoiManager.getInstance()

def putAreas(arealist):
  ** Take all areas of an AreaList and put them in the ROI Manager.**
  for layer in arealist.getLayerRange():
    area = arealist.getAreaAt(layer)
    if area is not None and not area.isEmpty():
      roi = ShapeRoi(area)
      getRoiManager().addRoi(roi)

def run():
  front = Display.getFront()
  layers = front.getLayerSet().getLayers()
  arealists = front.getSelection().getSelected(AreaList)
  if arealists.isEmpty():
    IJ.log("No arealists selected!")
    return
  # Extract areas as ROIs for the first one:
  putAreas(arealists[0])

run()

def putAreas(arealist):
  ** Take all areas of an AreaList and put them in the ROI Manager.**
  def put(arealist):
  map(getRoiManager().addRoi,
      map(ShapeRoi,
          filter(lambda area: not area.isEmpty(),
                 filter(None,
                        map(arealist.getAreaAt, arealist.getLayerRange())))))

# Obtain a pointer to the frontmost open display:
front = Display.getFront()
# Open an image
filepath = "/path/to/image.tif"
imp = IJ.openImage(filepath)
# Create a new Patch, which wraps an image
patch = Patch(front.project, imp.title, 0, 0, imp)
patch.project.loader.addedPatchFrom(filepath, patch)
# Add it to a layer
front.layer.add(patch)

# Albert Cardona 20100201
# Script to copy all images, all visible images, or all selected images
# from a source layer to a target layer.
# To run the script, put it under Fiji plugins folder or subfolder and call "Plugins - Scripting - Update Fiji"
# and make sure you have at least two projects open, each with at least one display open.
# 
# Written for Natalya at Graham Knott's group, EPFL

from ini.trakem2.display import *
from ij.gui import GenericDialog
from ij import IJ
from array import array


def run():
    # Check precondition: at least some displays open
    displays = Display.getDisplays()
    if displays.isEmpty():
        IJ.showMessage("Could not find any TrakEM2 displays open!")
        return
    # Check precondition: at least two displays from two different projects 
    projects = {}
    for display in displays:
        projects[display.project] = display
    if len(projects) < 2:
        IJ.showMessage("You need at least two projects with at least one display open for each!")
        return
    # Show choices
    gd = GenericDialog("Copying images between projects")
    titles = array(String, [display.getFrame().getTitle() for display in displays])
    gd.addChoice("Source layer:", titles, titles[0])
    gd.addChoice("Target layer:", titles, titles[1])
    choices = ["All images", "All visible images", "All selected images"]
    gd.addChoice("Copy:", choices, choices[0])
    gd.showDialog()
    if gd.wasCanceled():
        return
    source = displays[gd.getNextChoiceIndex()]
    target = displays[gd.getNextChoiceIndex()]
    if source == target:
        IJ.showMessage("You must choose different source and target layers!")
        return
    copy_mode = gd.getNextChoiceIndex()
    patches = None
    if 0 == copy_mode:
        patches = source.getLayer().getDisplayables(Patch)
    elif 1 == copy_mode:
        patches = source.getLayer().getDisplayables(Patch, True)
    else:
        patches = source.getSelection().getSelected(Patch)
    if 0 == len(patches):
        IJ.showMessage("No images to copy with option: " + choices[copy_mode])
        return
    # Copy images
    for patch in patches:
        p = patch.clone(target.project, False)
        target.getLayer().add(p)
    target.getLayerSet().enlargeToFit(patches)
    IJ.showStatus("Done copying images between layers.")

run()

# Albert Cardona 2010-06-30 for JC Rah
# Takes a list of project XML files
# and grabs all layers in order
# and clones each and all its images
# and then adds it to a newly created project named "all_layers.xml"


from ini.trakem2 import Project
from ini.trakem2.display import Patch
from ini.trakem2.utils import Utils
from ij import IJ


source_dir = "/path/to/projects/" # MUST have ending slash
project_paths = ["project1.xml", "project2.xml", "project3.xml"]

# folder to save the target project at
target_folder = source_dir

def merge_layers():
  # Create a new project target_folder as the storage folder:
  target = Project.newFSProject("blank", None, target_folder)
  # Save it there as "all_layers.xml" so we can call "save()" on it later
  target.saveAs(target_folder + "all_layers.xml", True)
  targetlayerset = target.getRootLayerSet()
  z = 0
  # For each project to concatenate, open it, and:
  for path in project_paths:
    IJ.log("Processing project " + path)
    project = Project.openFSProject(source_dir + path, False)
    rectangle = project.getRootLayerSet().get2DBounds()
    # For each layer in the project, create a new layer "targetlayer" to host a copy of its images:
    for layer in project.getRootLayerSet().getLayers():
      targetlayer = targetlayerset.getLayer(z, 1, True)
      z += 1
      # Add to the new layer copies of each image
      for ob in layer.getDisplayables():
        targetlayer.add(ob.clone(target, False)) # clone in the context of the target project
    project.getLoader().setChanged(False) # avoid dialog at closing
    project.destroy()
    targetlayerset.setMinimumDimensions()
  # Regenerate all image mipmaps
  futures = []
  for patch in targetlayerset.getDisplayables(Patch):
    futures.append(patch.updateMipMaps())
  Utils.wait(futures)
  target.save() # to validate mipmaps
  #target.destroy()  # comment out to close it
  IJ.log("Done!")

# Invoke the function!
merge_layers()

# Albert Cardona 20100201
# Select a Ball and a Profile, and list the minimal distances of each ball
# to the nearest vertex of the mesh created by the profile list to which
# the profile belongs.
# 
# As asked by Graham Knott and Natalya, from EPFL


from ini.trakem2.display import Display, Ball, Profile
from ini.trakem2.utils import M, Utils
from ij import IJ
from ij.measure import ResultsTable
from ij.gui import GenericDialog
from java.util import HashSet


def run():
	sel = Display.getSelected()
	# Check conditions: one Ball and one Profile only must be selected
	if sel is None or sel.isEmpty():
		IJ.log("Please select a Ball and a Profile!")
		return
	c = [ob.getClass() for ob in sel]
	if Ball in c and Profile in c and 2 == sel.size():
		pass
	else:
		IJ.log("Please select just one Ball and one Profile")
		return
	obs = {}
	for ob in sel:
		obs[ob.getClass()] = ob
	balls = obs[Ball].getWorldBalls()
	profile = obs[Profile]
	profiles = []
	# Gather triangles from profile mesh (into a HashSet to remove the many duplicate vertices)
	verts = HashSet(Profile.generateTriangles(profile.project.findProjectThing(profile).getParent(), 1))
	# Prepare a results table
	rt = ResultsTable()
	rt.setPrecision(2)
	rt.setHeading(0, "Index")
	rt.setHeading(1, "Min distance to surface")
	# Fill data rows
	unit = profile.layer.parent.calibration.unit
	i = 0
	count = len(balls)
	for i in range(count):
		rt.incrementCounter();
		rt.addLabel("units", unit)
		rt.addValue(0, i)
		b = balls[i]
		# For each ball, measure the minimal distance to any of the triangle vertices.
		rt.addValue(1, Math.sqrt(reduce(Math.min, [M.distanceSq(b[0], b[1], b[2], vert.x, vert.y, vert.z) for vert in verts])))
		Utils.showProgress(float(i)/count)
	rt.show("Distances from ball to profile list surface")
	# Reset progress bar
	Utils.showProgress(1)

run()

# The IDs of the Ball and AreaList instances
vesiclesID = 1543
synapticSurfaceID = 1541

# Obtain the two TrakEM2 instances
project = Project.getProjects()[0]
vesicles = project.findById(vesiclesID)
synapticSurface = project.findById(synapticSurfaceID)

# A set of unique vertices defining the synaptic surface
vertices = set(synapticSurface.generateTriangles(1, 2))

# For every vesicle, measure its shortest distance to a vertex
distances = [reduce(min, map(lambda v: p.distance(v), vertices))
			 for p in vesicles.asWorldPoints()]

# Compute average, median and standard deviation
mean = sum(distances) / len(distances)
stdDev = Math.sqrt(reduce(lambda s, e: s + pow(e - mean, 2),
						  distances, 0)) / len(distances)
median = sorted(distances)[len(distances)/2]

print mean, stdDev, median

z = 0
thickness = 12.5
# Obtain the LayerSet instance:
layerset = Display.getFront().getLayerSet()
#
for layer in layerset.getLayers():
  layer.setZ(z)
  layer.setThickness(thickness)
  z += thickness

# Update the GUI
layerset.getProject().getLayerTree().updateUILater()

# Acquire a reference the selected object in the Display
t = Display.getFront().getActive()
# If t is not a Tree, the following will fail:
root = t.getRoot()

nodes = root.getSubtreeNodes()

nodes = [nd for nd in nodes]

from ini.trakem2.display import Display
from jarray import array

def getNodeCoordinates(tree):
  ** Returns a map of Node instances vs. their X,Y,Z world coordinates. **
  root = tree.getRoot()
  if root is None:
	return {}
  calibration = tree.getLayerSet().getCalibration()
  affine = tree.getAffineTransform()
  coords = {}
  #
  for nd in root.getSubtreeNodes():
	fp = array([nd.getX(), nd.getY()], 'f')
	affine.transform(fp, 0, fp, 0, 1)
	x = fp[0] * calibration.pixelWidth
	y = fp[1] * calibration.pixelHeight
	z = nd.getLayer().getZ() * calibration.pixelWidth   # a TrakEM2 oddity
	# data may be a radius or a java.awt.geom.Area 
	coords[nd] = [x, y, z]
  #
  return coords

# Obtain the tree selected in the canvas:
tree = Display.getFront().getActive()

# Print all its node coordinates:
for node, coord in getNodeCoordinates(tree).iteritems():
  x, y, z = coord
  print "Coords for node", node, " : ", x, y, z

from ini.trakem2.display import Display
 
def sortNodesByTags(tree):
  table = {}
  root = tree.getRoot()
  if root is None:
	return table # empty
  #
  for nd in tree.getRoot().getSubtreeNodes():
	tags = nd.getTags()
	if tags is None:
	  continue
	for tag in tags:
	  tagged = None
	  if table.has_key(tag):
		tagged = table[tag]
	  else:
		tagged = []  
		table[tag] = tagged
	  tagged.append(nd)
  #
  return table
 
# Obtain the currently selected Tree in the canvas:
tree = Display.getFront().getActive()
 
# Print the number of nodes that have any given tag:
for tag, tagged in sortNodesByTags(tree).iteritems():
  print "Nodes for tag '" + str(tag) + "':", len(tagged)

from ini.trakem2.display import Display

# Obtain the currently selected Tree in the canvas:
tree = Display.getFront().getActive()

# Compute betweenness centrality
bc = tree.computeCentrality()   # a java.util.Map

# Print the value for each node
for e in bc.entrySet():
  print e.getKey(), "=>", e.getValue()

from ini.trakem2.display import Display
from java.awt import Color

def computeColor(centrality, highest):
  red = centrality / float(highest)
  blue = 1 - red
  return Color(red, red, blue)

# Obtain the currently selected Tree in the canvas:
tree = Display.getFront().getActive()

# Compute betweenness centrality
bc = tree.computeCentrality()   # a java.util.Map

# Find out the maximum centrality value, to scale:
maximum = reduce(max, bc.values())

# Colorize each node according to its centrality
for e in bc.entrySet():
  node = e.getKey()
  centrality = e.getValue()
  node.setColor(computeColor(centrality, maximum))

# Update display
Display.repaint()

# Show the tree in the 3D Viewer
Display3D.show(tree.getProject().findProjectThing(tree))

from ini.trakem2.display import Display
from java.awt import Color

def computeColor(degree, highest):
  blue = degree / float(highest)
  red = 1 - blue
  return Color(red, red, blue)

# Obtain the currently selected Tree in the canvas:
tree = Display.getFront().getActive()

# Compute betweenness centrality
degrees = tree.computeAllDegrees()   # a java.util.Map

# Find out the maximum degree value, to scale:
maximum = reduce(max, degrees.values())

# Colorize each node according to its degree:
for e in degrees.entrySet():
  node = e.getKey()
  degree = e.getValue()
  node.setColor(computeColor(degree, maximum))

# Update display
Display.repaint()

# Show the tree in the 3D Viewer
Display3D.show(tree.getProject().findProjectThing(tree))

from ini.trakem2.display import Display

# Obtain the currently selected treeline or areatree or connector:
tree = Display.getFront().getActive()

# A collection of all end nodes (not lazy):
endNodes = tree.getEndNodes()

# A lazy collection of all branch nodes:
branchNodes = tree.getBranchNodes()

# A lazy collection of both all end nodes and all branch nodes:
endOrBranchNodes = tree.getBranchAndEndNodes()

from ini.trakem2.display import Display, Connector, Tree

layerset = Display.getFront().getLayerSet()

# table of relationships: one source vs. its list of targets
graph = {}

for connector in layerset.getZDisplayables(Connector):
  targets = []
  for targetSet in connector.getTargets(Tree):
	for target in targetSet:
	  targets.append(target)
  for origin in connector.getOrigins(Tree):
	ls = None
	if graph.has_key(origin):
	  graph[origin] += targets
	else:
	  graph[origin] = targets

# print the graph (we print the id of each object):
for origin,targets in graph.iteritems():
  tids = ""
  for target in targets:
	tids += str(target.id) + ", "
  print origin.id, "=>", tids

# 2011-03-13 Albert Cardona for Nuno da Costa
# 
# For a given Treeline or AreaTree that represents a neuronal arbor,
# find all nodes that contain the tag "neck start"
# and for each of those find the distance to a node
# in their subtree that contains the tag "neck end".
#
# In short, measure the lengths of all spine necks
# labeled as such in the arbor.


from math import sqrt
from ini.trakem2.display import Display, AreaTree, Treeline

def findNeck(startNode):
  ** Assumes necks are not branched. ** 
  neck = []
  for node in startNode.getSubtreeNodes():
	tags = getTagsAsStrings(node)
	if tags is None or not "neck end" in tags:
	  neck.append(node) # growing the neck
	  continue
	# Else, end of neck:
	neck.append(node)
	return neck
  print "Did not find a node with an end tag, for parent node " + startNode
  return None # end tag not found!


def getTagsAsStrings(node):
  found = set()
  tags = node.getTags()
  if tags is None or 0 == len(tags):
	return found
  for tag in tags:
	found.add(tag.toString())
  return found


def measureSpineNecks(neuron):
  ** Expects an AreaTree or a Treeline for neuron.
  Assumes that nodes with a tag "neck start" are parents or superparents of nodes with tags of "neck end".
  **
  print "Measurements for neuron '" + str(neuron) + "':"
  for node in neuron.getRoot().getSubtreeNodes():
	# Check if the node has the start tag
	tags = getTagsAsStrings(node)
	if tags is None or not "neck start" in tags:
	  continue
	# Find its child node that has an end tag
	neck = findNeck(node)
	if neck is None:
	  continue
	distance = neuron.measurePathDistance(neck[0], neck[-1])
	print "  id:", neuron.getId(), "-- neck length: ", distance


def isTree(x):
  return isinstance(x, Treeline) or isinstance(x, AreaTree)



# Measure in all treelines or areatrees:
#trees = filter(isTree, Display.getFront().getLayerSet().getZDisplayables())

# Measure only in the selected treelines or areatrees:
trees = filter(isTree, Display.getSelected())

if 0 == len(trees):
  print "No trees found!"
else:
  for neuron in trees:
	measureSpineNecks(neuron)

##############
# Set a specific radius to all individual spheres
# of all Ball objects of a TrakEM2 project.


calibrated_radius = 40  # in microns, nm, whatever


display = Display.getFront()
layerset = display.getLayerSet()
cal = layerset.getCalibration()
# bring radius to pixels
new_radius = calibrated_radius / cal.pixelWidth

for ballOb in layerset.getZDisplayables(Ball):
  for i in range(ballOb.getCount()):
	ballOb.setRadius(i, new_radius)
  ballOb.repaint(True, None)
##############

# Open a text window containing all Ball objects as a CSV file,
# in calibrated coordinates.
# The text window has a "File - Save" menu for saving to a file.

# Albert Cardona 2015-07-02 for Jemima Burden at UCL.

# See also the API of the Ball class:
# https://github.com/trakem2/trakem2/blob/-/src/main/java/ini/trakem2/display/Ball.java#L716


from ini.trakem2.display import Display, Ball
from ij.text import TextWindow

ball_obs = Display.getFront().getLayerSet().getZDisplayables(Ball)

# One entry for each id,x,y,z,r 
rows = []

# Iterate every Ball instance, which contains one or more x,y,z,r balls
for ball_ob in ball_obs:
  id = ball_ob.getId()
  # Iterate every x,y,z,r ball of a Ball instance, calibrated
  wbs = ball_ob.getWorldBalls()
  for ball_coords in wbs:
	# Store every ball as a row with id, x, y, z, r
	rows.append(str(id) + "," + ",".join(str(c) for c in ball_coords))

csv = "\n".join(rows)

t = TextWindow("Balls CSV", csv, 400, 400)

from ini.trakem2.display import Display
from org.scijava.vecmath import Color3f
from customnode import WavefrontExporter, CustomTriangleMesh
from java.io import StringWriter
from ij.text import TextWindow

# Get the selected AreaList
arealist = Display.getSelected()[0]

# Create the triangle mesh with resample of 1 (no resampling)
# CAUTION: may take a long time. Try first with a resampling of at least 10.
resample = 1
triangles = arealist.generateTriangles(1, resample)

# Prepare a 3D Viewer object to provide interpretation
color = Color3f(1.0, 1.0, 0.0)
transparency = 0.0
mesh = CustomTriangleMesh(triangles, color, transparency)

# Write the mesh as Wavefront
name = "arealist-" + str(arealist.id)
m = {name : mesh}
meshData = StringWriter()
materialData = StringWriter()
materialFileName = name + ".mtl"
WavefrontExporter.save(m, materialFileName, meshData, materialData)

# Show the text of the files in a window
# then you save it with "File - Save"
TextWindow(".obj", meshData.toString(), 400, 400)
TextWindow(materialFileName, materialData.toString(), 400, 400)

triangles = areatree.generateMesh(1, resample).verts

Display.getFront().getProject().save()

Display.getFront().getProject().adjustProperties()

# Albert Cardona 2011-02-02
# At Madison, Wisconsin, with Erwin Frise
from ini.trakem2 import Project
from ij.gui import Toolbar
from java.awt import Color
from ij import ImagePlus

project = Project.newFSProject("blank", None, "/home/albert/Desktop/t2/")
loader = project.getLoader()
loader.setMipMapsRegeneration(False) # disable mipmaps
layerset = project.getRootLayerSet()
layerset.setSnapshotsMode(1) # outlines

task = loader.importImages(
		  layerset.getLayers().get(0),  # the first layer
		  "/home/albert/Desktop/t2/example-data/images/list.txt", # the absolute file path to the text file with absolute image file paths
		  " ", # the column separator  <path> <x> <y> <section index>
		  1.0, # section thickness, defaults to 1
		  1.0, # calibration, defaults to 1
		  False, # whether to homogenize contrast, avoid
		  1.0) # scaling factor, default to 1

task.join() # Optional: wait until all images have been imported

# Export a snapshot of the layer at 25% magnification

scale = 0.25
layer = layerset.getLayers().get(0)
flat = loader.makeFlatImage(ImagePlus.COLOR_RGB, layer, layerset.get2DBounds(), scale, layer.getAll(Patch), Color.black)

imp = ImagePlus("snap " + str(scale), flat).show()

print "done!"

from ini.trakem2.display import Display, Patch
from java.awt import Color

front = Display.getFront() # the active TrakEM2 display window
layer = front.getLayer()
tiles = front.getSelection().get(Patch)  # selected Patch instances only
backgroundColor = Color.black
scale = 0.5

roi = tiles[0].getBoundingBox()
for tile in tiles[1:]:
  roi.add(tile.getBoundingBox())

print "Creating flat image from", len(tiles), "image tiles"

ip = Patch.makeFlatImage(
		   ImagePlus.GRAY16,
		   layer,
		   roi,
		   scale,
		   tiles,
		   backgroundColor,
		   True)  # use the min and max of each tile

imp = ImagePlus("Flat montage", ip)
imp.show()

# Albert Cardona 2010-03-19 at EMBL
# Specially demo'ed for Larry Lindsey

def doSomething(evt):
  IJ.showMessage("Button pushed!")

def addReconstructToolkit(display):
  tabs = display.getTabbedPane()
  # Check that it's not there already
  title = "Reconstruct toolbar"
  for i in range(tabs.getTabCount()):
	if tabs.getTitleAt(i) == title:
	  IJ.showMessage("Reconstruct toolbar already in this Display!")
	  return
  # Otherwise, add it new:
  from javax.swing import JPanel, JButton
  pane = JPanel()
  b = JButton("Push it", actionPerformed=doSomething)
  pane.add(b)
  tabs.add(title, pane)


front = Display.getFront()
if front is not None:
  addReconstructToolkit(front)
else:
  IJ.showMessage("Open a display first!")