diff --git a/BIOP_VSI_reader.ijm b/BIOP_VSI_reader.ijm
index 570e740..c00b609 100644
--- a/BIOP_VSI_reader.ijm
+++ b/BIOP_VSI_reader.ijm
@@ -1,1241 +1,1243 @@
 // Action Bar description file :  BIOP_VSI_reader
 // By Olivier Burri & Romain Guiet
 // EPFL BIOP 2014
 
 /*
  * DESCRIPTION: Simple Action Bar to open and make sense of the Olympus OlyVIA Slide Scanner
  * The macro works as follows
  * Uses Jerome Mutterer's Action Bar Plugin as the interface.
  * Takes advantage of the print "Update" Function as of IJ 1.38m to keep data in memory.
  * Uses LOCI BioFormats to read and parse the data from the VSI reader
  * 
  * MOTIVATION: Images produced by the OlyVIA Scanner are extremely large (>48'000px) 
  * The inherent limitation of Java (or IJ) for images is about 48'000px
  * Because the .vsi files have preview thumbnails, we want to use those in order to 
  * navigate the data and open only the part of the image we're interested in.
  * A Simple navigator is provided for convenience.
  * 
  * DISCLAIMER: This is a work in progress and some bugs are bound to pop up, don't hesitate to contact us in case you have problems
  * at olivier.burri at epfl.ch 
  */
 
 
 // Action Bar settings
 sep = File.separator;
 
 // Install the BIOP Library
 call("BIOP_LibInstaller.installLibrary", "BIOP"+sep+"BIOPLib.ijm");
 
-
-run("Action Bar", "jar:file:BIOP/BIOP_VSI_reader.jar!/BIOP_VSI_reader.ijm");
-
 //////////////////////////////////////////////////////////////////////////////////////////////
 // The line below is for debugging. Place this VSI file in the ActionBar folder within Plugins
 //////////////////////////////////////////////////////////////////////////////////////////////
 //run("Action Bar", "/plugins/ActionBar/BIOP_VSI_reader.ijm");
 
+// This is the default run behaviour
+run("Action Bar", "jar:file:BIOP/BIOP_VSI_reader.jar!/BIOP_VSI_reader.ijm");
+
+
+
 
 exit();
 //Start of ActionBar
 
 <codeLibrary>
 
 function toolName() {
   return "VSI Reader";
 }
 
 function isVSI(filename) {
 	if(endsWith(filename, ".vsi")) {
 		return true;
 	}
 	return false;
 }
 
 /*
  * openLociStack opens the stack at the given index. This index is the raw index of the image as interpreted by LOCI
  * It starts at 1 and should be used in conjuction with the "getSeriesIndex... series of functions to ensure it works properly
  * Based on an example by Wayne Rasband on the LOCI Website
 */
 function openLociStack(name, index) {
 	run("Bio-Formats Macro Extensions");
 	id = getID();
 	Ext.setId(id);
 	    
 	// Place yourself at the desired series Index (starts at 0);
 	Ext.setSeries(index);
 
 	// Get ther dimensions
 	Ext.getSizeC(sizeC);
 	Ext.getSizeZ(sizeZ);
 	Ext.getSizeT(sizeT);
 	Ext.getSizeX(sizeX);
 	Ext.getSizeY(sizeY);
 
 	
 	Ext.getImageCount(n);
 	print(index);
 
 	//Start opening the series
 	setBatchMode(true);
 	for (i=0; i<n; i++) {
 		showProgress(i, n);
 		
 		Ext.openSubImage("Plane "+i, i, 0,0, sizeX, sizeY);
 		if (i==0) {
 			stack = getImageID;
 		}else {
 			run("Copy");
 			close;
 			selectImage(stack);
 			run("Add Slice");
 			run("Paste");
 		}
 	}
 	//Rename it
 	rename(name);
 	if (nSlices>1) {
 		Stack.setDimensions(sizeC, sizeZ, sizeT);
 		if (sizeC>1) {
 			if (sizeC==3&&sizeC==nSlices)
 				mode = "Composite";
 		    	else
 		      		mode = "Color";
 		      		
 		   	run("Make Composite", "display="+mode);
 		}
 		setOption("OpenAsHyperStack", true);
 	}
 	setBatchMode(false);
 	run("Select None");
 
 }
 /*
  * Same as above, but opens a sub-region of the image
 */
 function openLociSubStack(name, index, posX, posY, w, h) {
 	run("Bio-Formats Macro Extensions");
 	id = getID();
 	Ext.setId(id);
 	Ext.setSeries(index);
 	Ext.getSizeC(sizeC);
 	Ext.getSizeZ(sizeZ);
 	Ext.getSizeT(sizeT);
 	Ext.getImageCount(n);
 		
 	setBatchMode(true);
 	for (i=0; i<n; i++) {
 		showProgress(i, n);
 		Ext.openSubImage("Plane"+i, i, posX , posY, w, h);
 		if (i==0)
 		    	stack = getImageID;
 		else {
 		    run("Copy");
 		    close;
 		    selectImage(stack);
 		    run("Add Slice");
 		    run("Paste");
 		    
 		}
 	}
 	rename(name);
 	if (nSlices>1) {
 		cMode = getData("Camera Mode");
 		Stack.setDimensions(sizeC, sizeZ, sizeT);
 		if (sizeC>1) {
 			if (sizeC==3&&sizeC==nSlices)
 		      		mode = "Composite";
 		    	else
 		     		 mode = "Color";
 		    	run("Make Composite", "display="+mode);
 		
 		}
 		setOption("OpenAsHyperStack", true);
 		if (cMode == "Brightfield") {
 			for (i=0; i<sizeC; i++) {
 				setSlice(i+1);
 				resetMinAndMax;
 			}
 			//run("RGB Color");
 		}
 	}
 	setBatchMode(false);
 	run("Select None");
 	
 	
 	
 }
 
 /*
  * To set the calibration of the images. 
  * Overwrite simply decides on how to deal with calibration values already existing
  */
 function getCalibrationVSI(series, overwrite) {
 	
    	// Offer a global calibration for this VSI file. or all VSI files
    	isGlobal = getBool("Global Calibration");
    	if (isGlobal) 
    		pixelSize = getData("Pixel Size");
    	else
    		pixelSize = getData("Pixel Size Series #"+series);
    		
    	if (overwrite || pixelSize == "") {
 		choices = newArray("Brightfield", "Fluorescence");
 		magnifications = newArray("2x", "4x", "10x", "20x", "40x");
 		// No Binning
 		bin = 1;
 		// CCDsize for our B/W camera: Olympus XM10 
 		ccd = 6.45;
 		// No c-Mount magnification on either camera
 		cm = 1.0;
 		    	
 		Dialog.create("Set Pixel Size for series #"+series);
 		Dialog.addChoice("Magnification used", magnifications, magnifications[0]);
 		 Dialog.addChoice("Imaging Mode", choices, choices[0]);
 		 Dialog.addCheckbox("Global Calibration", false);
 		 Dialog.addMessage("Will not display calibration dialog for \nsubsequent series of this file")
 		 Dialog.show();
 		
 		mag=Dialog.getChoice();
 		mag = parseInt(substring(mag, 0,indexOf(mag,"x")));
 		mode=Dialog.getChoice();
 		isGlobal = Dialog.getCheckbox();
 		if (mode == "Brightfield") {
 			// Color camera on our system: PIKE Allied Tech F505C
 			ccd = 3.45*2;
 		}
 		// Do the calculation proper.
 		pixelSize=(ccd*bin)/(mag*cm);
 		setData("Camera Mode", mode);
 
    	}
    	if (isGlobal) {
    		setData("Pixel Size", pixelSize);
    		setBool("Global Calibration", isGlobal);
    	} else {
    		setData("Pixel Size Series #"+series, pixelSize);
    	}
    	
    	// Set the mode, so we can decide how to display the image
    	
    		
 		return pixelSize;
      }
 
 /*
  *  Sets the calibration on the current image
  */ 
 function setCalibrationVSI(cal) {
      	setVoxelSize(cal,cal, 1, "micron");
 }
 
 /*
  * Setting and recovering the ID of the current fuile
  */
 function getID() {
 	id = getData("Series ID");
 	return id;
 }
 	
 function setID(id) {
 	setData("Series ID",id);
 }
 	
 /*
  *  Extracts the name of the image from its directory+file string
  */ 
 function getImageName() {
 	name = getData("Series ID");
 	name = substring(name, lastIndexOf(name, File.separator)+1,lengthOf(name));
 	return name;
 }
 // Extracts the directory
 function getImageDirectory() {
 	name = getData("Series ID");
 	dir = substring(name, 0, lastIndexOf(name, File.separator)+1);
 	return dir;
 }
 
 /* parseSeriesData(fileID)
  *  Serves for the analysis of the series, using the following rules:
  *  All pyramidal series are ordered from largest to smallest size (512x512).
  *  The intermediate sizes seem incomplete...
  *  
  */ 
 function parseSeriesData(fileID) {
 	run("Bio-Formats Macro Extensions");
 	setID(fileID);
 	Ext.setId(fileID);
 
 	// Get the total number of images in the .VSI file.
 	Ext.getSeriesCount(seriesCount);
 
 
 	setData("totSeries", seriesCount);
 
 	// Now we count the data
 	fullSeries = 0;
 	s = 0;
 	lastIndex = 0;
 	while (s < seriesCount) {
 		Ext.setSeries(s);
 		Ext.getSizeX(sizeX);
 		Ext.getSizeY(sizeY);
 		//print(s,":", sizeX, sizeY);
 		
 		// If it's 512;
 		if(sizeX == 512 && sizeY == 512) {
 			// get the one after
 			//This is a series
 			fullSeries++;
 			// Last index tells us where we stopped finding new series
 			lastIndex = s+1;
 			// skip the next one
 			//s+=1;
 		}
 		s+=1; //increment search
 	}
 	setData("Last Index",lastIndex);
 	/*
 	 *  now from lastIndex to the end we should be able to discover some things about the image
 	 *  first one is the overview (always there)
 	 *  second is the label( if defined)
 	 *  third is the 2x preview (always there)
 	 *  fourth is the mask (maybe)
 	 *  
 	 *  A trick, calculate from the last series, going back up how many 'micro' thumbnails there are, this gives seriesNum
 	 */ 
 	oldnSeries = getNSeriesFromThumbs();
 
 	// Now: Magic!
 	
 	unacctountedSeries = fullSeries - oldnSeries;
 	// Logically there should be 1 or two
 	// if 1, then it's the 2X preview
 	// if 2, then it's the label and the 2X preview
 	// if 0, then no 2x preview....
 	hasPreview = true;
 	hasLabel = false;
 	if (unacctountedSeries == 2 ) {
 		hasLabel = true;
 	} else if (unacctountedSeries == 1) {
 		hasLabel = false;
 	}
  else if (unacctountedSeries == 0) {
 		// No 2x Preview!!!!!
 		hasPreview = false; 
 	}
 	print("Unaccounted series: "+unacctountedSeries);
 	setBool("Has label", hasLabel);
 	setBool("Has Preview", hasPreview);
 
 	// Now we should know everything.
 	// check if it has the mask
 	// See what remains
 	mask = seriesCount - lastIndex - 2*oldnSeries - 1 - hasLabel - hasPreview;
 	// This value should be 0 or 1
 	print("mask (",mask,")= ", seriesCount ,"-",  lastIndex, "-", 2*oldnSeries, "- 2 -",  hasLabel);
 
 	if(mask == 1) {
 		hasMask = true;
 	} else {
 		hasMask = false;
 	}
 
 	setBool("Has mask", hasMask);
 	
 	setData("nSeries", oldnSeries);
 	setData("Mode", "Normal");
 	return 1;
 	}
 
 function getLabelPos() {
 	hasLabel = getBool("Has label");
 	if(hasLabel) {
 		lIdx = getData("LastIndex");
 		return lIdx+1;	
 	} else  {
 		return -1;
 	}
 }
 
 function getOverviewPos() {
 	lIdx = parseInt(getData("Last Index"));
 	return lIdx;
 }
 
 function get2xPreviewPos() {
 	hasLabel = getBool("Has label");
 	hasPreview = getBool("Has Preview");
 
 	
 if (hasPreview) {
 		if(hasLabel) {
 			pos = getRawSeriesPos(2);
 		} else {
 			pos = getRawSeriesPos(1);
 		}
 	} else {
 		pos = -1;
 	}
 	return pos;
 }
 
 function getMaskPos() {
 	hasMask = getBool("Has mask");
 	nS = parseInt(getData("nSeries"));
 	totS = parseInt(getData("totSeries"));
 	pos = -1;
 	if(hasMask) {
 		pos = (totS-2*nS-1);
 	}
 	return pos;
 }
 
 function getNSeriesFromThumbs() {
 	run("Bio-Formats Macro Extensions");
 	fileID = getID();
 	Ext.setId(fileID);
 	serN = parseInt(getData("totSeries"));
 	oldSeries = 0;
 	// Run this baby backwards
 	for (i=serN-1; i>=0; i--) {
 		Ext.setSeries(i);
 		Ext.getSizeX(sizeX);
 		Ext.getSizeY(sizeY);
 		if(sizeX < 100 && sizeY < 100)
 			oldSeries++;		
 	}
 	return oldSeries;	
 }
 	
 function getRawSeriesPos(series) {
 	serN = parseInt(getData("totSeries"));
 	nextSer = 0;
 	nSer=1;
 	//print("Searching for Series ", series);
 	for (i=0; i<serN; i++) {
 		Ext.setSeries(i);
 		Ext.getSizeX(sizeX);
 		Ext.getSizeY(sizeY);
 		// If it's 512;
 		if(sizeX == 512 && sizeY == 512) {
 		//print("End of ", nSer-1, "next series at ", series);
 		nextSer = i+1;
 		nSer++;
 		}
 		if ((nSer-1) == series) {
 		return nextSer;
 		}
 	}
 	return nextSer;
 }
 
 function getSeriesPos(series) {
 	hasLabel = getBool("Has label");
 	hasPreview = getBool("Has Preview");
 
 	pos = getRawSeriesPos(series+hasLabel+hasPreview);
 
 	return pos;
 }
 	
 	//Gives the thumbnail's position, to use with openLociStack and such
 
 function getSeriesThumbPos(series) {
 	hasLabel = getBool("Has label");
 	hasPreview = getBool("Has Preview");
 	
 	series+=hasLabel+hasPreview;
 
 	//print("Looking for thumb of series ", series);
 	serN = parseInt(getData("totSeries"));
 	nextSer = 0;
 	thumbPos = 0;
 	for (i=0; i<serN; i++) {
 		Ext.setSeries(i);
 		Ext.getSizeX(sizeX);
 		Ext.getSizeY(sizeY);
 		//print("Looking at series ", i, ":", sizeX, sizeY);
 		// If it's 512;
 		if(sizeX == 512 && sizeY == 512) {
 		nextSer++;
 		thumbPos = i;
 		}
 		if (nextSer-1 == series) {
 		//print("Found at position ", thumbPos);
 		return thumbPos;
 		}
 	}
 	return thumbPos;
 	}
 	
 function getResamplingRate(series) {
 	hasLabel = getBool("Has label");
 	hasPreview = getBool("Has Preview");
 	
 	series+=hasLabel+hasPreview;
 
 	//print("Gettting Resampling Rate for series ", series);
 	serN = parseInt(getData("totSeries"));
 	activeSerInd = 0;
 	currentSer =0;
 	resampling = -1;
 	for (i=0; i<serN; i++) {
 		Ext.setSeries(i);
 		Ext.getSizeX(sizeX);
 		Ext.getSizeY(sizeY);
 		// If it's 512;
 		if(sizeX == 512 && sizeY == 512) {
 		// We reached the end of a series and can now get the sampling factor
 		//print("End of series: i=", i, ", actSerInd=", activeSerInd);
 		//print("Resampling: ", resampling, "X");
 		resampling = pow(2,(i-(activeSerInd)));
 		activeSerInd = i+1;
 		currentSer++;
 		}
 
 		if (currentSer-1 == series) {
 		//print("Found: ", resampling, "X");
 		return resampling;
 		}
 	}
 	return resampling;
 	
 }
 
 function getAvailableRates(samplingRate) {
 	n = log(samplingRate)/log(2);
 	rates = newArray(n);
 	for (i=0; i<n; i++) {
 		rates[i] = ""+parseInt(pow(2,i));
 	}
 	return rates;
 }
 
 function getSeriesSize(series) {
 	Ext.setSeries(series);
 	Ext.getSizeX(sizeX);
 	Ext.getSizeY(sizeY);
 	Ext.getSizeZ(sizeZ);
 	Ext.getSizeC(sizeC);
 	Ext.getSizeT(sizeT);
 
 	sizes = newArray(sizeX, sizeY, sizeZ, sizeC, sizeT);
 
 	return sizes;
 
 	
 }
 /* 
  * After the data is parsed, we can get build a dialog to prompt the user for the series he wants to open.
  *  right not works for Normal mode, after the 5.0.1 update of Loci Bioformats. More as we get more samples
  *  again.
 */
 function generateDialogAndOpenSeries() {
 	mode = getData("Mode");
 	if (mode == "Normal") {
 		theName = getImageName();
 		Dialog.create(theName+": Pick Series");
 		serN = parseInt(getData("nSeries"));
 
 		hasLabel = getBool("Has label");
 		hasMask = getBool("Has mask");
 		hasPreview = getBool("Has Preview");
 
 				
 		if (hasLabel)
 			Dialog.addCheckbox("Label", false);
 		
 		if (hasMask) 
 			Dialog.addCheckbox("Mask", false);
 			
 		
 		Dialog.addCheckbox("Overview", false);
 
 		if (hasPreview) {
 			Dialog.addCheckbox("2X Preview", false);
 		}
 		
 		for(i=0; i<serN; i++) {
 			ser = getSeriesPos(i);
 			mag = getResamplingRate(ser);
 			
 			Ext.setSeries(ser);
 		
 			Ext.getSizeX(sizeX);
 			Ext.getSizeY(sizeY);
 
 		// Here we should be able to distinguish labels and previews...
 		Dialog.addCheckbox("Series #"+i+"("+sizeX+", "+sizeY+")", true);
 		}
 		
 			
 			
 		Dialog.show();
 
 		if (hasLabel) {
 			if(Dialog.getCheckbox()) {
 				openThumbnail(-2);
 				rename("Label from "+theName);
 			}
 		}
 		if (hasMask) {
 			if(Dialog.getCheckbox()) {
 				maskPos = getMaskPos();
 				//print(maskPos);
 				openLociStack("Mask from "+theName, maskPos);
 			}
 		}
 		
 		// Check if we want to open the mini-preview
 		if(Dialog.getCheckbox()) {
 				overviewPos = getOverviewPos();
 				openLociStack("Overview from "+theName, overviewPos);		
 		}
 		
 				
 		if (hasPreview) {
 			if(Dialog.getCheckbox()) {
 				previewPos = get2xPreviewPos(); //TODO refactor
 				openThumbnail(-1);
 			}
 		}
 
 
 
 		//Now open the thumbnails
 		for(i=0; i<serN; i++) {
 			if(Dialog.getCheckbox()) {
 				openThumbnail(i);		
 			}
 
 		}
 	}
 }
 
 // To open the Thumbnail of the selected series
 function openThumbnail(series) {
 	theName = getImageName();
 	run("Bio-Formats Macro Extensions");
 	id = getID();
 	Ext.setId(id);
 	
 	ser = getSeriesPos(series);
 	
 	serThumb = getSeriesThumbPos(series);
 	
 	mag = getResamplingRate(series);
 
 	// Let's make the thumbnail the right size
 	Ext.setSeries(ser);
 	Ext.getSizeX(sizeX);
 	Ext.getSizeY(sizeY);
 
 	
 	openLociSubStack(""+ser+" - Series #"+series+" (Thumbnail) from "+theName, serThumb, 0,0, (sizeX/mag), (sizeY/mag));
 	
 	
 	run("Set Scale...", "distance=1 known="+(mag)+" pixel=1 unit=unit");
 }
 
 // Loads the current selection made on a thumbnail at 100% Size
 function loadCurrentSelection(rescaling) {
 	step = 64;
 	run("Bio-Formats Macro Extensions");
 	id = getID();
 	Ext.setId(id);
 	name = getTitle();
 	serPos = parseInt(substring(name,0,indexOf(name, "-")-1));
 	serInd = parseInt(substring(name,indexOf(name,"#")+1,lengthOf(name)));
 	//serPos=getSeriesPos(serInd);
 	if(selectionType != -1) {
 		//Get the coordinates of the box
 		getSelectionBounds(x, y, width, height);
 		//And the sizes of the image
 	  	//Get the samplign factor from the pyramidal format
 		mag = getResamplingRate(serInd);
 		  
 		// print("Rescaling: ", rescaling);
 		if ( (round(rescaling) - rescaling == 0 ) && rescaling%2 == 0) {
 			mag = mag/(rescaling);
 			serPos = serPos + round((log(rescaling)/log(2)));
 		}
 		// The the size of the resl series
 		Ext.setSeries(serPos);
 		Ext.getSizeX(sizeX);
 		Ext.getSizeY(sizeY);
 		
 		oriX = round( (mag * (x)) * (1));
 		oriY = round( (mag * (y)) * (1));
 		oriW = ( floor(mag * (width) / step) +1 ) * step;
 		oriH = ( floor(mag * (height) / step) +1 ) * step;
 
 		  	
 		if (oriX + oriW > sizeX) {
 			neworiW = sizeX - oriX;
 			print("Size of image exceeds image dimensions, cropping:");
 			print("Original Width: "+oriW+" , New Width: "+neworiW);
 			oriW = neworiW;
 		}
 		if (oriY + oriH > sizeY) {
 			neworiH = sizeY - oriY;
 			print("Size of image exceeds image dimensions, cropping:");
 			print("Original Height: "+oriH+" , New Height: "+neworiH);
 			oriH = neworiH;
 		}
 
 	
 		// Append rescaling factor to image name
 		
 if (rescaling != 1) {
 			rescaleText = " Scaling "+rescaling;
 		} else {
 			rescaleText = "";
 		}
 		
 		// Make sure that the chosen size is not larger than what imageJ can handle
 		if( oriW > 42000 || oriH > 42000) {
 			showMessage("Your selection is too large ("+oriX+", "+oriY+")\n  Please select a smaller area");
 		} else if(matches(name,".*Thumbnail.*")) {
 			openLociSubStack("Series #"+serInd+" at ("+oriX+", "+oriY+")"+rescaleText, (serPos), oriX, oriY, oriW , oriH);
 		} else {
 			showMessage("Please Select a Thumbnail Image!");
 		}
 	} else {
 		showMessage("Please make a selection");
 	}
 }
 
 function measureCurrentImageWithMacro(){
 	macroToMeasure = getData("Macro Image Processing and Measurement Path");
 	runMacro(macroToMeasure);
 }
 
 
 function createMaskFromROIs(measureStatus){
 	Stack.getDimensions(widthOri, heightOri, channelsOri, slicesOri, framesOri) 
 		
 	n = roiManager("Count"); 						// get thu total number of ROI to process
 	currentCat = "*none*";							// set current categorie name to 'none'
 	
 	// Here, the macro will create a new channel for each category
 	// and will fill all ROI with a random grey value
 	for (i=0; i<n; i++) {
 		roiManager("Select", i);					// select the ROI 'i'
 		name = call("ij.plugin.frame.RoiManager.getName", i);		// get the ROI name and number
 		cat = substring(name, 0, lastIndexOf(name,"#")-1);		// extract the Name
 		catNum=parseInt(substring(name, lastIndexOf(name,"#")+1));	// get the number of the ROI, and convert to number (need to be include in a Result Table)
 		if (cat != currentCat) {					// if the Name is NOT the same than the previous one
 			Stack.getDimensions(width, height, channels, slices, frames) ;
 			Stack.setChannel(channels);				// set to last channels
 			run("Add Slice", "add=channel");			// add a new channel
 			currentCat = cat;					// define the current categorie
 									//
 									
 			color = round(225-random()*200);			// create a "random" value between 25 et 225
 			setForegroundColor(color, color, color);		// use the same value to create a grey one
 			Stack.getDimensions(width, height, channels, slices, frames) ;
 			Stack.setChannel(channels);				// set  to the last channels created
 			run("Fill", "slice");					// fill the roi with 
 		}
 
 		if (measureStatus){
 			for (frameIndex = 1 ; frameIndex <= framesOri ; frameIndex++){
 				Stack.setFrame(frameIndex);				// set the Frame
 				for (channelIndex = 1 ; channelIndex <= channelsOri ; channelIndex++){
 					Stack.setChannel(channelIndex);			// set the Channel
 					for (sliceIndex =1 ; sliceIndex <= slicesOri; sliceIndex++){
 						Stack.setSlice(sliceIndex);		// set the Slice
 						run("Measure");				// measure
 						setResult(currentCat, nResults-1, catNum);// in the result table, add ROI number, to the corresponding row, at the 'categorie name' column
 					}
 						
 				}
 			}	
 		}
 	}
 	updateResults();
 }
 
 </codeLibrary>
 
 
 <line>
 <button>
 label=Select a VSI File
 icon=icons/load-vsi-48.png
 arg=<macro>
 // Make sure that a new Parameters window is opened for each series
 // This is what needs to be modified. We need to check
 // What consequences this has.
 
 winTitle = getWinTitle();
 win = "["+winTitle+"]";
 if(isOpen(winTitle)) {
 	selectWindow(winTitle);
 	run("Close");
 	run("New... ", "name="+win+" type=Table");
 	print(win, "\\Update0:This window contains data the macro needs. Please don't close it");
 }
 id = File.openDialog("Choose a Tile Scanner File");
 res = parseSeriesData(id);
 generateDialogAndOpenSeries();
 </macro>
 
 
 <button>
 label=Extract current ROI
 icon=icons/loadSelection-48.png
 arg=<macro>
 // Make a selection and import the series
 name = getTitle();
 serInd = parseInt(substring(name,indexOf(name,"#")+1,lengthOf(name)));
 // Calibrate the image
 // Check if the calibration is there already, or prompt for it
 cal = getCalibrationVSI(serInd, false);
 loadCurrentSelection(1);
 setCalibrationVSI(cal);
 </macro>
 
 <button>
 label=Save As Tiff
 icon=icons/saveAsTiff-48.png
 arg=<macro>
 // Just a simple button to call the Save As Tiff menu
 run("Tiff...");
 </macro>
 
 
 
 </line>
 <text><html><font size=3 color=#0C2981>Extra Tools
 <line>
 
 
 <button>
 label=Downsample Selection
 icon=icons/Resize2-48.png
 arg=<macro>
 //Need width and height of current Image
 run("Bio-Formats Macro Extensions");
 id = getID();
 Ext.setId(id);
 name = getTitle();
 serInd = parseInt(substring(name,indexOf(name,"#")+1,lengthOf(name)));
 serPos = parseInt(substring(name,0,indexOf(name, "-")-1));
 // Check if the calibration is there already
 
 cal = getCalibrationVSI(serInd, false);
 
 if(selectionType != -1) {
 	//Get the coordinates of the box
 	getSelectionBounds(x, y, width, height);
 	mag = getResamplingRate(serInd);
 	//And the sizes of the image
 	
   	oriX = mag * (x);
   	oriY = mag * (y);
   	oriW = mag * (width);
   	oriH = mag * (height);
   	
 	
 	
 	rescaleChoice = getAvailableRates(mag);
 	
 	//Rescale factor
 	continueRescale = false;
 	Dialog.create("Rescaling");
 	
 	Dialog.addChoice("Rescaling Factor", rescaleChoice, rescaleChoice[0]);
 	
 	
 	while(!continueRescale) {
 		Dialog.show();
 		fac = parseInt(Dialog.getChoice());
 	 	continueRescale = getBoolean("Your original image is "+oriW+" x "+oriH+"px\n"+"And will now be "+floor(oriW/fac)+" x "+floor(oriH/fac)+" px\n\n Do you wish to continue?");
 	}
 
 	loadCurrentSelection(fac);
 	
 	setCalibrationVSI(cal*fac);
 </macro>
 
 
 <button>
 label=Place Scalebar
 icon=icons/scale1-48.png
 arg=<macro>
 run("Scale Bar...");
 </macro>
 <button>
 label=Convert to RGB
 icon=icons/rgb-48.png
 arg=<macro>
 setBatchMode(true);
 getVoxelSize(width, height, depth, unit);
 showStatus("Converting to RGB...");
 run("Flatten");
 showStatus("Converting to RGB... Done");
 // Set Scale
 setCalibrationVSI(width);
 wait(10);
 setBatchMode(false);
 </macro>
 </line>
 
 <line>
 <button>
 label=Load Parameters
 icon=icons/loadParams-48.png
 arg=<macro>
 loadParameters();
 </macro>
 
 <button>
 label=Save Parameters
 icon=icons/saveParams-48.png
 arg=<macro>
 // Save the Parameters
 saveParameters();
 </macro>
 </line>
 <text><html><font size=3 color=#0C2981>Create ROI for extraction
 <line>
 <button>
 label=Load macro tp detect ROI of extraction
 icon=icons/LoadMacroDetection-48.png
 arg=<macro>
 macroFile = File.openDialog("Select the macro to run");
 setData("Macro Path for ROI detection", macroFile);
 </macro>
 
 <button>
 label = Run Macro (current image)
 icon=icons/runMacro-48.png
 arg=<macro>/////////////////////////////////////////////////////////////// added by Romain 2014.03.26
 roiNumStartRename = roiManager("Count");				// get the number of existing ROI
 macroFile = getData("Macro Path for ROI detection");			// get the macro
 if(macroFile == ""){
 	macroFile = File.openDialog("Select the macro to run");
 	setData("Macro Path for ROI detection", macroFile);
 }
 image = getTitle();							// Rename this region of interest
 serNum = parseInt(substring(image, indexOf(image,"#")+1, indexOf(image, "(")-1));//get image infos, serie Number 
 cal = getData("Pixel Size Series #"+serNum);
 if (cal == ""){
 	cal = getCalibrationVSI(serNum, false);
 }
 
 runMacro(macroFile);							// run the macro that create ROIs					
 
 for (roiNum=roiNumStartRename ; roiNum <roiManager("count") ; roiNum++){// for the newly created ROI
 	roiManager("select",roiNum);					// select the ROI
 	roiManager("Rename", image+" ROI #"+(roiNum)+" cal "+cal);	// rename it using informations
 }
 
 </macro>
 
 <button>
 label = Run macro (batch)
 icon=icons/runMacroFolder-48.png
 arg=<macro>
 ////////////////////////////////////////////////////////////////////added by Romain 2014.03.26
 path = getDirectory("Select a fodler containing VSI image(s)");
 fileList = getFileList(path);
 
 macroFile = getData("Macro Path for ROI detection");
 if(macroFile == ""){
 	macroFile = File.openDialog("Macro Path for ROI detection");
 	setData("Macro Path for ROI detection", macroFile);
 }
 
 
 seriesTotalNumber = getData("nSeries");	
 txt = "0";
 if (seriesTotalNumber > 1) {
 	for (i=i; i<seriesTotalNumber; i++) {
 		txt+=","+i;
 	}
 }
 
 Dialog.create("Select series");
 Dialog.addMessage("Select series from vsi you want to use");
 Dialog.addCheckbox("On all series", true);
 Dialog.addString("On serie(s) : ", txt);
 Dialog.show();
 
 allSeriesStatus = Dialog.getCheckbox() ;
 seriesSelectedByUserString = Dialog.getString();
 if (allSeriesStatus){
 	selectedSeries = split(txt,",");
 }else{
 	selectedSeries = split(seriesSelectedByUserString, ",");
 }
 
 
 for (fileIndex = 0 ; fileIndex < lengthOf(fileList);fileIndex++){
 	if(isVSI(fileList[fileIndex])){
 
 		id = path+fileList[fileIndex];
 		//parseSeriesData re-reads the .vsi file to make sure all the following functions are working properly.
 		res = parseSeriesData(id);
 
 		if(res==-1){
 			showMessage("Error : cannot parse vsi file. \nContact BIOP staff.");
 		}else{
 			//seriesTotalNumber = getData("nSeries");				//get the number of series inside vsi 
 		
 			for (index = 0 ; index <selectedSeries.length ;index++ ){
 						
 				//serPos=getSeriesPos(serNum);
 				//Open the thumbnail of the series if it's not open
 				openThumbnail(selectedSeries[index]);
 				
 				roiNumStartRename = roiManager("Count");				// get the number of existing ROI
 				
 				image = getTitle();							// Rename this region of interest
 				serNum = parseInt(substring(image, indexOf(image,"#")+1, indexOf(image, "(")-1));//get image infos, serie Number 
 				cal = getData("Pixel Size Series #"+serNum);
 				if (cal == ""){
 					cal = getCalibrationVSI(serNum, false);
 				}
 			
 				runMacro(macroFile);							// run the macro that create ROIs					
 				
 				for (roiNum=roiNumStartRename ; roiNum <roiManager("count") ; roiNum++){// for the newly created ROI
 					roiManager("select",roiNum);					// select
 					
 					roiManager("Rename", image+" ROI #"+(roiNum)+" cal "+cal);
 				}
 			}
 		}
 	}
 }
 </macro>
 </line>
 
 
 
 
 
 <line>
 <button>
 label=Add ROI to manager
 icon=icons/addRoi-48.png
 arg=<macro>
 // Add to Manager
 image = getTitle();
 roiManager("Add");
 roinum = roiManager("count");
 roiManager("select",roinum-1);
 serNum = parseInt(substring(image, indexOf(image,"#")+1, indexOf(image, "(")-1));
 cal = getCalibrationVSI(serNum, false);
 roiManager("Rename", image+" ROI #"+(roinum)+" cal "+cal);
 
 </macro>
 
 <button>
 label=Delete selected ROI
 icon=icons/removeRoi-48.png
 arg=<macro>
 // Reseting the ROI manager
 nRoi = roiManager("count");
 if (nRoi > 0) {
 	roiManager("Select", nRoi-1);
 	roiManager("Delete");
 }
 </macro>
 
 <button>
 label=Clear all ROIs
 icon=icons/clearRois-48.png
 arg=<macro>
 // Reseting the ROI manager
 roiManager("reset");
 </macro>
 </line>
 <line>
 
 <button>
 label=Load ROIs
 icon=icons/loadRois-48.png
 arg=<macro>
 // Load ROIs
 roiManager("Open", "");
 </macro>
 
 <button>
 label=Save ROIs
 icon=icons/saveRois-48.png
 arg=<macro>
 // Saving the ROIs
 roiManager("Save", "");
 </macro>
 </line>
 
 <line>
 <button>
 label=Process ROIs for extraction
 icon=icons/process-48.png
 arg=<macro>
 
 rescaleChoice = getAvailableRates(128);
 
 // How to save the selections?
 Dialog.create("Save Images");
 Dialog.addMessage("Image Parameters:");
 Dialog.addCheckbox("Save as RGB?", false);
 Dialog.addMessage("Only check above when saving Brightfield images!");
 
 Dialog.addCheckbox("Run macro for each series?", false);
 Dialog.addCheckbox("Save all images in same folder?", true);
 Dialog.addChoice("Rescaling Factor", rescaleChoice, rescaleChoice[0]);
 Dialog.show();
 
 RGB	= Dialog.getCheckbox();
 rMacro  = Dialog.getCheckbox();
 isSameFolder  = Dialog.getCheckbox();
 downscaleFactor = parseInt(Dialog.getChoice());
 
 macroPath = getData("Macro Path");
 
 if(rMacro && macroPath == "") {
 	macroFile = File.openDialog("Select the macro to run");
 	setData("Macro Path", macroFile);
 }
 
 // Start with the current series, use that to get the directory
 id = getID();
 dir = getImageDirectory();
 
 // Use the ROI data to select the image, series and calibration before using it.
 n = roiManager("count");
 
 if (n==0) 
 	exit("No ROIS");
 
 for (i=0; i<n; i++) {
 	roiName = call("ij.plugin.frame.RoiManager.getName", i);
 	// Extract the data from the name
 	serNum = parseInt(substring(roiName, indexOf(roiName,"#")+1, indexOf(roiName, "(")-1));
 	fileName = substring(roiName, indexOf(roiName,"from ")+5, indexOf(roiName, ".vsi")+4);
 	thumbName = substring(roiName, 0, indexOf(roiName, ".vsi")+4);
 	cal = parseFloat(substring(roiName, lastIndexOf(roiName,"cal ")+4, lengthOf(roiName)));
 	roiNum = substring(roiName, indexOf(roiName, "ROI #")+5, lastIndexOf(roiName, " cal "));
 	//print (roiNum);
 	// Now we can get to the loading bit
 	// Set the right series and load the data, as well as the thumbnail!
 	// Parse the data first
 	//print(serNum);
 	//New ID, in case it changes
 	id = dir+fileName;
 	
 	//parseSeriesData re-reads the .vsi file to make sure all the following functions are working properly.
 	res = parseSeriesData(id);
 	
 	serPos=getSeriesPos(serNum);
 
 	//Open the thumbnail of the series if it's not open
 	if (!isOpen(thumbName)) {
 		openThumbnail(serNum);
 	}
 
 	//Now we can start the extraction
 	selectWindow(thumbName);
 	roiManager("select", i);
 	scale = downscaleFactor;
 	loadCurrentSelection(scale);
 	newCal = cal*scale;
 	setCalibrationVSI(newCal);
 	
 	/* Images are loaded. Now what to do
 	*  1. Save original
 	*  2. Apply whatever macro (Macro should handle saving)
 	*/
 
 	// Saving
 	sep = File.separator;
 	if (isSameFolder) {
 		savingPathName = dir+sep+"Extracted"+sep;
 	} else {
 		savingPathName = id+"_extracted"+sep;
 	}
 	
 	File.makeDirectory(savingPathName);
 	name = getTitle();
 		
 	if (RGB) {
 		run("RGB Color");
 		run("Properties...", "unit=micron pixel_width="+(cal*scale)+" pixel_height="+(cal*scale));
 			
 		saveAs("Tiff", savingPathName+fileName+"_Series_"+serNum+"_ROI_"+roiNum+"_RGB.tif");
 		rgbName = getTitle();
 		selectWindow(name);
 		close();
 		selectWindow(rgbName);
 				
 	} else {
 		saveAs("Tiff", savingPathName+fileName+"_Series_"+serNum+"_ROI_"+roiNum+"_Ori.tif");
 	}
 
 	if (rMacro) {
 		// Recover macro path...
 		macroPath = getData("Macro Path");
 		runMacro(macroPath, savingPathName );
 	}
 	close();
 }
 </macro>
 
 
 </line>
 <text><html><font size=3 color=#0C2981> Image Processing and Measurement
 <line>
 
 <button>
 label=Load Macro for image processing and measurement
 icon=icons/LoadMacroMeasure-48.png
 arg=<macro>
 macroFile = File.openDialog("Select the macro to run");
 setData("Macro Image Processing and Measurement Path", macroFile);
 </macro>
 
 <button>
 label = Run Macro (current image)
 icon=icons/runMacro-48.png
 arg=<macro>/////////////////////////////////////////////////////////////// added by Romain 2014.03.26
 macroFile = getData("Macro Image Processing and Measurement Path");
 if (macroToMeasure==""){
 	macroFile = File.openDialog("Macro Image Processing and Measurement Path");
 	setData("Macro Image Processing and Measurement Path", macroFile);
 }
 runMacro(macroToMeasure);
 
 </macro>
 
 <button>
 label = Run macro (batch)
 icon=icons/runMacroFolder-48.png
 arg=<macro>
 run("Clear Results");
 nI = getNumberImages();
 for (i=0; i<nI; i++) {
 	roiManager("reset");
 	openImageN(i);
 	n= roiManager("Count");
 	if (n>0) {
 		macroFile = getData("Macro Image Processing and Measurement Path");
 		if (macroFile==""){
 			macroFile = File.openDialog("Macro Image Processing and Measurement Path");
 			setData("Macro Image Processing and Measurement Path", macroFile);
 		}
 		measureCurrentImageWithMacro();
 		
 		saveCurrentImage();				// save the last image selected
 		saveRois("Save");				// and associated ROI
 	}
 	//Close the image(s) before going to the next one
 	run("Close All");
 }
 </macro>
 </line>
diff --git a/BIOP_VSI_reader.jar b/BIOP_VSI_reader.jar
index 3036bb8..a8dfddb 100644
Binary files a/BIOP_VSI_reader.jar and b/BIOP_VSI_reader.jar differ