diff --git a/BIOP_VSI_reader.ijm b/BIOP_VSI_reader.ijm
index 3503df4..da1a2c6 100644
--- a/BIOP_VSI_reader.ijm
+++ b/BIOP_VSI_reader.ijm
@@ -1,1351 +1,1353 @@
 // 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
  * Bug 18.05.2012: Navigator: Not obvious when macro finished working. Find a way to stop the position update more easily.
  */
 
 
 // Action Bar settings
 sep = File.separator;
 
 // Install the BIOP Library
 call("BIOP_LibInstaller.installLibrary", "BIOP"+sep+"BIOPLib.ijm");
 
 runFrom = "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
 //////////////////////////////////////////////////////////////////////////////////////////////
 //runFrom = "/plugins/ActionBar/BIOP_VSI_reader.ijm";
 
 
 print("Running From: "+runFrom);
 
 
 run("Action Bar", runFrom );
 
 
 exit();
 //Start of ActionBar
 
 <codeLibrary>
 
 /*
  * Must be set for the function library to work
  */
 function toolName() {
   return "VSI Reader";
 }
 
 
 /*
  * Flag to set for debugging
  */
 function isDebug() {
 	return false;
 }
 
 
 /*
  * Debug print. If a debug flag is set, then print, otherwise do nothing. 
  */
 function dprint(text) {
 	
deb = isDebug();
 	if (deb) {
 		print(text);
 	}
 }
 /*
  * isVSI just checks at the file extension
  */
 function isVSI(filename) {
 	if(endsWith(filename, ".vsi")) {
 		return true;
 	}
 	return false;
 }
 
 
 
 /*
  * Setting and recovering the ID of the current fuile
  */
 function getID() {
 	id = getData("Series ID");
 	return id;
 }
 	
 function setID(id) {
 	setData("Series ID",id);
 	dir = substring(id, 0,lastIndexOf(id,File.separator)+1);
 	setData("Image Folder",dir);
 	
 }
 	
 /*
  *  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) {
 	dprint("Parsing Series Data for "+fileID);
 	offset = log(getThumbnailSize())/log(2) -9 ;
 	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);
 
	dprint("Total number of series in VSI file: "+seriesCount);
 
 	// Now we count the data
 	fullSeries = 0;
 	s = 0;
 	lastIndex = 0;
 	
 	dprint("Finding how many thumbnails ("+512+"x"+512+") images there are...");
 	while (s < seriesCount) {
 		Ext.setSeries(s);
 		Ext.getSizeX(sizeX);
 		Ext.getSizeY(sizeY);
 		//print(s,":", sizeX, sizeY);
 		
dprint("Series "+s+ " is "+sizeX+" x "+sizeY+ "px");
 		// If it's thumbSize;
 		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;
 			dprint("Series Found."+fullSeries+" Total series. Last index of series: "+lastIndex);
 			// skip the next one
 		}
 		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!
 	
 	unaccountedSeries = fullSeries - oldnSeries;
 	dprint("Series unaccounted for: "+unaccountedSeries);
 	// 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 (unaccountedSeries == 2 ) {
 		hasLabel = true;
 	} else if (unaccountedSeries == 1) {
 		hasLabel = false;
 	}
 else if (unaccountedSeries == 0) {
 		// No 2x Preview!!!!!
 		hasPreview = false; 
 	}
 	
 	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;
 }
 
 /*
  * This function looks at images based on the nanoscopic thumbnails residing in the VSI file
  */
 function getNSeriesFromThumbs() {
 	run("Bio-Formats Macro Extensions");
 	fileID = getID();
 	Ext.setId(fileID);
 	serN = parseInt(getData("totSeries"));
 	oldSeries = 0;
 	// Run this baby backwards
 	dprint("Running backwards to find number of thumbnails (No labels or overviews)");
 	for (i=serN-1; i>=0; i--) {
 		Ext.setSeries(i);
 		Ext.getSizeX(sizeX);
 		Ext.getSizeY(sizeY);
 		if(sizeX < 100 && sizeY < 100)
 			oldSeries++;		
 	}
 	dprint("Found "+oldSeries+" thumbnails smaller than 100px");
 	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 thumbSize;
 		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");
 	offset = log(getThumbnailSize())/log(2) -9 ;
 	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 thumbSize;
 		if(sizeX == 512 && sizeY == 512) {
 		nextSer++;
 		thumbPos = i;
 		}
 		if (nextSer-1 == series) {
 		dprint("Found at position "+ thumbPos+ " applying offset of "+offset);
 		return thumbPos-offset;
 		}
 	}
 	return thumbPos-offset;
 	}
 	
 function getResamplingRate(series) {
 	hasLabel = getBool("Has label");
 	hasPreview = getBool("Has Preview");
 	offset = log(getThumbnailSize())/log(2) -9 ;
 	
 	series+=hasLabel+hasPreview;
 
 	dprint("Getting 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
 		dprint("End of series: i="+i+ ", actSerInd="+ activeSerInd);
 		dprint("Resampling: "+ resampling+ "X");
 		resampling = pow(2,(i-(activeSerInd)-offset));
 		activeSerInd = i+1;
 		currentSer++;
 		}
 
 		if (currentSer-1 == series) {
 		dprint("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() {
 	roiManager("Reset");
 	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
 		count =0;
 		for(i=0; i<serN; i++) {
 			if(Dialog.getCheckbox()) {
 				openThumbnail(i);
 				count++;
 			}
 		}
 		if (count == 1) {
 			name = getTitle();
 			openRoiSet(name);
 		}
 	}
 }
 
 // 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)));
 	
 	//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 = " Scaled "+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!");
 	}
 
 }
 
 /*
  * 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);
 		//Ext.openImage("Plane "+i, i);
 		
 		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 == "") {
    		// Get some info on the opened image:
 		getDimensions(w,h,c,z,t);
 		choices = newArray("Brightfield", "Fluorescence");
 		if (c == 3) {
 			default = "Brightfield";
 		} else {
 			default = "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, default);
 		 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");
 }
 
 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();
 }
 
 function makeGrid(selectedSize) {
 	//Make grid based on selection  or whole image
 	getSelectionBounds(x, y, width, height);
 	
 	// Set Color 
 	color = "red";
 	
 	// Calculate how many boxes we will need based on a user-selected size
 	
 	// Then we need the calibration, which gives us the REAL pixel size
 	getVoxelSize(px,py,pz,unit);
 	
 	// To get the size of the ROIs to draw on the image
 	sizeOnThumb = selectedSize/px;
 	
 	// Thus we will need
 	nBoxesX = ceiling(width/sizeOnThumb);
 	nBoxesY = ceiling(height/sizeOnThumb);
 	
 	run("Remove Overlay");
 	roiManager("Reset");
 	
 	for(j=0; j<nBoxesY; j++) {
 		for(i=0; i<nBoxesX; i++) {
 			makeRectangle(x+i*sizeOnThumb, y+j*sizeOnThumb, sizeOnThumb,sizeOnThumb);
 			
 			addRoi(false);
 		}	
 	}
 
 	saveRois("Open");
 	
 	run("Select None");
 }
 
 function ceiling(value) {
 	tol = 0.4;
 	if (value - round(value) > tol) {
 		return round(value)+1;
 	} else {
 		return round(value);
 	}
 }
 
 function countRoiFiles() {
 	roiDir = getRoiFolder("Open");
 	roiFiles = getFileList(roiDir);
 	c=0;
 	for(i=0; i<roiFiles.length; i++) {
 		if (endsWith(roiFiles[i], ".zip"))
 			c++;
 	}
 	return c;
 }
 
 function addRoi(isSave) {
 	image = getTitle();
 	roinum = roiManager("Count");
 	serNum = parseInt(substring(image, indexOf(image,"#")+1, indexOf(image, "(")-1));
 	cal = getCalibrationVSI(serNum, false);
 	Roi.setName(image+" ROI #"+(roinum+1)+" cal "+cal);
 	roiManager("Add");
 	if (isSave) {saveRois("Open"); }
 }
 
 function processRois() {
 	// First define the folder to use
 	dir = setImageFolder("Where are the VSI Files?");
 	
 	rescaleChoice = getAvailableRates(128);
 	
 	// How to save the selections?
 	Dialog.create("Save Images");
 	Dialog.addMessage("Image Parameters:");
 	Dialog.addCheckbox("Run macro for each extracted series?", false);
 	Dialog.addCheckbox("Save all images in same folder?", true);
 	Dialog.addChoice("Downsample by a factor of", rescaleChoice, rescaleChoice[0]);
 	Dialog.show();
 	
 	//Save as RGB or not
 	cameraMode = getData("Camera Mode");
 	if (cameraMode == "Brightfield") {
 		RGB	= true;
 	} else {
 		RGB = false;
 	}
 	
 	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);
 	}
 	
 	// What we need to know is how many ROI files there are and open them
 	// Which means get the file list of the Roi Set
 	roiDir = getRoiFolder("Open");
 	roiList = getFileList(roiDir);
 
 	if (countRoiFiles() == 0)
 		exit("No Rois");
 	
 	for (k = 0; k< roiList.length; k++) {
 		if (endsWith(roiList[k], ".zip")) {
 			roiManager("Reset");
 			roiManager("Open", roiDir+roiList[k]);
 	
 	
 			// 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 "));
 				
 				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 (indexOf(name, "Scaling") != -1) {
 					scaling = "_"+replace(substring(name, indexOf(name, "Scaling"), lengthOf(name))," ", "_");
 				} else {
 					scaling = "";
 				}
 				if (RGB) {
 					name = getTitle();
 					
 					run("RGB Color");
 					run("Properties...", "unit=micron pixel_width="+(cal*scale)+" pixel_height="+(cal*scale));
 					
 					saveAs("Tiff", savingPathName+fileName+"_Series_"+serNum+"_ROI_"+roiNum+scaling+"_+RGB.tif");
 					rgbName = getTitle();
 					
 					selectWindow(name);
 					
 					close();
 					
 					selectImage(rgbName);
 					
 				} else {
 					saveAs("Tiff", savingPathName+fileName+"_Series_"+serNum+"_ROI_"+roiNum+scaling+"_Ori.tif");
 				}
 			
 				if (rMacro) {
 					// Recover macro path...
 					macroPath = getData("Macro Path");
 					runMacro(macroPath, savingPathName );
 				}
 				close();
 				
 			}
 		}
 	}
 }
 function getSeriesAsArray() {
 	nSer = parseInt(getData("nSeries"));
 	seriesArray = newArray(nSer);
 	for(i=0;i<nSer;i++) {
 		seriesArray[i] = i;
 	}
 	return seriesArray;
 }
 
 function runRoiExtractionMacro() {
 	////////////////////////////////////////////////////////////////////added by Romain 2014.03.26
 
 	path = getDirectory("Select a fodler containing VSI image(s)");
 	
 	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) : ", "");
 	Dialog.addCheckbox("No macro, just extract whole image", false);
 	Dialog.show();
 
 	
 	allSeriesStatus = Dialog.getCheckbox() ;
 	seriesSelectedByUserString = Dialog.getString();
 	isWholeImage = Dialog.getCheckbox() ;
 	
 	if (allSeriesStatus){
 		selectedSeries = "all";
 	}else{
 		selectedSeries = split(seriesSelectedByUserString, ",");
 	}
 
 	macroFile = getData("Macro Path for ROI detection");
 	if(macroFile == "" && !isWholeImage){
 		macroFile = File.openDialog("Macro Path for ROI detection");
 		setData("Macro Path for ROI detection", macroFile);
 	}
 
 	
 	fileList = getFileList(path);
 	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{
 				
 				if (allSeriesStatus) {
 					// Get number of series
 					selectedSeries = getSeriesAsArray();
 				}
 				for (index = 0 ; index <selectedSeries.length ;index++ ){
 					roiManager("Reset");	
 					//serPos=getSeriesPos(serNum);
 					//Open the thumbnail of the series if it's not open
 					openThumbnail(selectedSeries[index]);
 					
 					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);
 					}
 
 					if(!isWholeImage) {
 						runMacro(macroFile);			// run the macro that create ROIs
 						// For the newly created ROI
 						for (roiNum=0 ; roiNum <roiManager("count") ; roiNum++){
 							roiManager("select",roiNum);
 							roiManager("Rename", image+" ROI #"+(roiNum)+" cal "+cal);
 						}
 						saveRois("Open");
 							
 					} else {
 						run("Select All");
 						addRoi(true);
 						
 					}
 				}
 			}
 		}
 	}
 }
 
 function getThumbnailSize() {
 	return 512;
 }
 
 </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>
 <line>
 <button>
 label=The buttons below offer extra functionality to manage your images.
 icon=icons/extraTools-48.png
 bgcolor=#efefef
 arg=<macro>
 </macro>
 </line>
 <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;
 	
 	while(!continueRescale) {
 		Dialog.create("Downsampling");
 		Dialog.addChoice("Downsample by a factor of", rescaleChoice, rescaleChoice[0]);
 		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=Use buttons below to manage your ROIs
 icon=icons/roiManagement-48.png
 bgcolor=#efefef
 arg=<macro>
 </macro>
 </line>
 <line>
 
 <button>
 label=Load macro to 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 = Batch Extract ROIs
 icon=icons/runMacroFolder-48.png
 arg=<macro>
 runRoiExtractionMacro();
 </macro>
 </line>
 
 
<line>
 
 <button>
 label=Add ROI to manager
 icon=icons/addRoi-48.png
 arg=<macro>
 // Add to Manager
 addRoi(true);
 
 </macro>
 
 <button>
-label = Make from ROI
+label = Make grid from ROI
 icon=icons/grid-48.png
 
 arg=<macro>
 	boxSizes = newArray("1024", "2048", "4096");
 	Dialog.create("Make Grid");
 	Dialog.addChoice("Image size for XY [px]", boxSizes, boxSizes[0]);
 	Dialog.show();
 	boxSize = parseInt(Dialog.getChoice());
 	makeGrid(boxSize);
+	// Known BUG, when rescaling, the grid shows some overlap.
+	
 </macro>
 
 
 
</line>
 <line>
 <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");
 }
 saveRois("Open");
 </macro>
 
 
 <button>
 label=Clear all ROIs
 icon=icons/clearRois-48.png
 arg=<macro>
 // Reseting the ROI manager
 roiManager("reset");
 </macro>
 </line>
 
 <line>
 <button>
 label=Process ROIs for extraction
 icon=icons/process-48.png
 arg=<macro>
 
processRois();	
 </macro>
 </line>
diff --git a/BIOP_VSI_reader.jar b/BIOP_VSI_reader.jar
index eac11a8..ab43da7 100644
Binary files a/BIOP_VSI_reader.jar and b/BIOP_VSI_reader.jar differ