/
Restack_Huygens_TIFF_deconvolved_images.py
462 lines (430 loc) · 27.7 KB
/
Restack_Huygens_TIFF_deconvolved_images.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
import os, sys
import java, jarray, array
#from jarray import array
import math
from java.awt import Frame, Dialog, Button
from java.awt.event import ActionEvent, ActionListener
from java.io import File
from java.lang import System, Integer
from ij import IJ, ImageStack, ImagePlus, ImageListener, VirtualStack, WindowManager
from ij.gui import GenericDialog
from ij.io import OpenDialog, FileSaver
from ij.plugin import LutLoader, ZProjector, HyperStackConverter
from ij.process import ImageProcessor, FloatProcessor, ShortProcessor, ByteProcessor
from fiji.util.gui import GenericDialogPlus
from loci.plugins import BF
from loci.plugins.in import ImporterOptions
from loci.plugins.util import BFVirtualStack
from loci.formats import ImageReader, ChannelSeparator
from loci.formats.in import MetamorphReader
def openMainDialogBox():
#od = OpenDialog("Selectionner un fichier")
#folder = od.getDirectory()
#IJ.log(folder);
#filename = od.getFileName() #intérêt de récupérer le nom du fichier -> récupérer l'extension
#extension = od.getFileName().split('.').pop() #Array.pop(). Pratique pour faire une fonction getExtension()
#IJ.log(folder+filename)
# Create an instance of GenericDialogPlus
mainDialogBox = GenericDialogPlus("Restack Tiff deconvolved images from Huygens")
mainDialogBox.addMessage("Ne fonctionnera correctement que si les noms des fichiers images de sortie de Huygens ont ete laisses intacts. Ne pas les modifier.")
#mainDialogBox.addButton("Ouvrir image", imageSelectionListener())
mainDialogBox.addMessage("------------------------------------------")
mainDialogBox.addDirectoryField("Choisir un repertoire-cible", "None")
mainDialogBox.addMessage("------------------------------------------")
mainDialogBox.addDirectoryField("Choisir un repertoire pour deposer les piles d'images", "None")
mainDialogBox.addMessage("------------------------------------------")
#Select File Type
choixType = ["1 fichier par canal (NOM_FICHIER_chXX.tif)", "1 fichier par canal + temps (NOM_FICHIER_tXX_chXX.tif)", "1 fichier par canal et par profondeur (NOM_FICHIER_zXX_chXX.tif)", "1 fichier par canal et par profondeur + temps (NOM_FICHIER_tXX_zXX_chXX.tif)"]
selectionType = choixType[0]
mainDialogBox.addChoice("Selectionner type de fichiers",choixType,selectionType)
mainDialogBox.addMessage("------------------------------------------")
choixDisplayMode = ["Color", "Greyscale", "Composite"]
selectionDisplayModeDefaut = choixDisplayMode[0]
mainDialogBox.addChoice("Color Display Mode",choixDisplayMode,selectionDisplayModeDefaut)
mainDialogBox.addMessage("------------------------------------------")
#Affichage de la boîte de dialogue
mainDialogBox.showDialog();
#Récupération choix
folder = mainDialogBox.getNextString()
save_folder = mainDialogBox.getNextString()
vecteurChoix=mainDialogBox.getChoices()
selectionTypeFichier = vecteurChoix[0]
valeurSelectionTypeFichier = str(selectionTypeFichier.getSelectedItem())
selectionDisplayMode = vecteurChoix[1]
valeurSelectionDisplayMode = str(selectionDisplayMode.getSelectedItem())
if mainDialogBox.wasCanceled() == True:
print("Canceled, Values set to None")
folder = None
save_folder = None
valeurSelectionTypeFichier = None
valeurSelectionDisplayMode = None
return folder, save_folder, valeurSelectionTypeFichier, valeurSelectionDisplayMode
def get_tif_files(folder):
tifFileList = []
for file in os.listdir(folder):
if file.endswith(".tif"):
tifFileList.append(file)
return tifFileList
def getListOfFileNameRoots(ListOfTifFilesToDo, valeurSelectionTypeFichier):
listOfFileNameRoots = []
for tifFileToDo in ListOfTifFilesToDo:
tifFileToDoParsedName = str(tifFileToDo).split("_")
channelIdentifierExtension = tifFileToDoParsedName.pop(-1)
channelIdentifier = channelIdentifierExtension.split(".")[0]
if valeurSelectionTypeFichier == "1 fichier par canal (NOM_FICHIER_chXX.tif)":
tifFileToDoParsedNameCorrected = "_".join(tifFileToDoParsedName)
if valeurSelectionTypeFichier == "1 fichier par canal + temps (NOM_FICHIER_tXX_chXX.tif)":
timeIdentifier = tifFileToDoParsedName.pop(-1)
tifFileToDoParsedNameCorrected = "_".join(tifFileToDoParsedName)
if valeurSelectionTypeFichier == "1 fichier par canal et par profondeur (NOM_FICHIER_zXX_chXX.tif)":
depthIdentifier = tifFileToDoParsedName.pop(-1)
tifFileToDoParsedNameCorrected = "_".join(tifFileToDoParsedName)
if valeurSelectionTypeFichier == "1 fichier par canal et par profondeur + temps (NOM_FICHIER_tXX_zXX_chXX.tif)":
depthIdentifier = tifFileToDoParsedName.pop(-1)
timeIdentifier = tifFileToDoParsedName.pop(-1)
tifFileToDoParsedNameCorrected = "_".join(tifFileToDoParsedName)
if tifFileToDoParsedNameCorrected not in listOfFileNameRoots:
listOfFileNameRoots.append(tifFileToDoParsedNameCorrected)
return listOfFileNameRoots
def orderChannelsInDictionary(ListOfTifFilesToDo, valeurSelectionTypeFichier):
mainDictionary = {}
listOfFileNameRoots = getListOfFileNameRoots(ListOfTifFilesToDo, valeurSelectionTypeFichier)
for fileNameRoot in listOfFileNameRoots:
fileChannelsDictionary = {}
for tifFileToDo in ListOfTifFilesToDo:
tifFileToDoParsedName = str(tifFileToDo).split("_")
channelIdentifierExtension = tifFileToDoParsedName.pop(-1)
channelIdentifier = channelIdentifierExtension.split(".")[0]
if valeurSelectionTypeFichier == "1 fichier par canal (NOM_FICHIER_chXX.tif)":
tifFileToDoParsedNameCorrected = "_".join(tifFileToDoParsedName)
if str(tifFileToDoParsedNameCorrected) == str(fileNameRoot):
if str(channelIdentifier) not in sorted(fileChannelsDictionary.keys()):
fileChannelsDictionary[str(channelIdentifier)] = {}
fileChannelsDictionary[str(channelIdentifier)] = tifFileToDo
if valeurSelectionTypeFichier == "1 fichier par canal + temps (NOM_FICHIER_tXX_chXX.tif)":
timeIdentifier = tifFileToDoParsedName.pop(-1)
tifFileToDoParsedNameCorrected = "_".join(tifFileToDoParsedName)
if str(tifFileToDoParsedNameCorrected) == str(fileNameRoot):
if str(channelIdentifier) not in sorted(fileChannelsDictionary.keys()):
fileChannelsDictionary[str(channelIdentifier)] = {}
fileChannelsDictionary[str(channelIdentifier)][str(timeIdentifier)] = tifFileToDo
if valeurSelectionTypeFichier == "1 fichier par canal et par profondeur (NOM_FICHIER_zXX_chXX.tif)":
depthIdentifier = tifFileToDoParsedName.pop(-1)
tifFileToDoParsedNameCorrected = "_".join(tifFileToDoParsedName)
if str(tifFileToDoParsedNameCorrected) == str(fileNameRoot):
if str(channelIdentifier) not in sorted(fileChannelsDictionary.keys()):
fileChannelsDictionary[str(channelIdentifier)] = {}
fileChannelsDictionary[str(channelIdentifier)][str(depthIdentifier)] = tifFileToDo
if valeurSelectionTypeFichier == "1 fichier par canal et par profondeur + temps (NOM_FICHIER_tXX_zXX_chXX.tif)":
depthIdentifier = tifFileToDoParsedName.pop(-1)
timeIdentifier = tifFileToDoParsedName.pop(-1)
tifFileToDoParsedNameCorrected = "_".join(tifFileToDoParsedName)
if str(tifFileToDoParsedNameCorrected) == str(fileNameRoot):
if str(channelIdentifier) not in sorted(fileChannelsDictionary.keys()):
fileChannelsDictionary[str(channelIdentifier)] = {}
if str(depthIdentifier) not in sorted(fileChannelsDictionary[str(channelIdentifier)].keys()):
fileChannelsDictionary[str(channelIdentifier)][str(depthIdentifier)] = {}
if str(timeIdentifier) not in sorted(fileChannelsDictionary[str(channelIdentifier)][str(depthIdentifier)].keys()):
fileChannelsDictionary[str(channelIdentifier)][str(depthIdentifier)][str(timeIdentifier)] = {}
fileChannelsDictionary[str(channelIdentifier)][str(depthIdentifier)][str(timeIdentifier)] = tifFileToDo
mainDictionary[str(fileNameRoot)] = fileChannelsDictionary
return mainDictionary
def getDirectoryContent(folder, valeurSelectionTypeFichier):
#fileList = os.listdir(folder) #= get_tif_files()
ListOfTifFilesToDo = get_tif_files(folder)
ListOfTifFilesToDo.sort()
print("ListOfTifFilesToDo", str(ListOfTifFilesToDo))
mainDictionary = orderChannelsInDictionary(ListOfTifFilesToDo, valeurSelectionTypeFichier) #Organise les noms des fichiers de façon à rassembler en une liste les canaux d'une seule image, chaque sera ajoutée à la liste d'assemblages de canaux.
print("mainDictionary: "+str(mainDictionary))
imagesList = []
for mainFileKey in sorted(mainDictionary.keys()):
fileChannelsDictionary = mainDictionary[mainFileKey]
filesChannelsImpsDictionary = {}
filesChannelsImpsList = []
for channels_dict_key in sorted(fileChannelsDictionary.keys()): #Trie chaque liste de canaux pour les canaux soient dans le bon ordre
numberOfChannels = len(fileChannelsDictionary[channels_dict_key])
if valeurSelectionTypeFichier == "1 fichier par canal (NOM_FICHIER_chXX.tif)":
seriesOfImageFile = openImageFile(folder, fileChannelsDictionary[channels_dict_key])
filesChannelsImpsList.append(seriesOfImageFile[0])
if valeurSelectionTypeFichier == "1 fichier par canal + temps (NOM_FICHIER_tXX_chXX.tif)":
tTimesArray = []
for timeKey in sorted(fileChannelsDictionary[channels_dict_key].keys()):
seriesOfImageFile = openImageFile(folder, fileChannelsDictionary[channels_dict_key][timeKey])
tTimesArray.append(seriesOfImageFile[0])
tTimesArray.sort()
filesChannelsImpsList.append(tTimesArray)
if valeurSelectionTypeFichier == "1 fichier par canal et par profondeur (NOM_FICHIER_zXX_chXX.tif)":
zDepthsArray = []
for zDepthKey in sorted(fileChannelsDictionary[channels_dict_key].keys()):
seriesOfImageFile = openImageFile(folder, fileChannelsDictionary[channels_dict_key][zDepthKey])
zDepthsArray.append(seriesOfImageFile[0])
zDepthsArray.sort()
filesChannelsImpsList.append(zDepthsArray)
if valeurSelectionTypeFichier == "1 fichier par canal et par profondeur + temps (NOM_FICHIER_tXX_zXX_chXX.tif)":
zDepthsArray = []
for zDepthKey in sorted(fileChannelsDictionary[channels_dict_key].keys()):
tTimesArray = []
for timeKey in sorted(fileChannelsDictionary[channels_dict_key][zDepthKey].keys()):
seriesOfImageFile = openImageFile(folder, fileChannelsDictionary[channels_dict_key][zDepthKey][timeKey])
tTimesArray.append(seriesOfImageFile[0])
zDepthsArray.append(tTimesArray)
filesChannelsImpsList.append(zDepthsArray)
filesChannelsImpsDictionary[mainFileKey] = filesChannelsImpsList
imagesList.append(filesChannelsImpsDictionary)
return imagesList
def assembleChannelImagesInStacks(imageTitle, arrayOfImages, valeurSelectionDisplayMode, valeurSelectionTypeFichier):
maxNumberOfChannels = len(arrayOfImages)
maxNumberOfZDepth = 1;
maxNumberOfTimeStamps = 1;
print("assembleChannelImagesInStacks - arrayOfImages: "+str(arrayOfImages))
for channelNumber in range(len(arrayOfImages)):
if valeurSelectionTypeFichier == "1 fichier par canal (NOM_FICHIER_chXX.tif)":
numberOfZDepth = len(arrayOfImages[channelNumber])
if numberOfZDepth > maxNumberOfZDepth:
maxNumberOfZDepth = numberOfZDepth
if valeurSelectionTypeFichier == "1 fichier par canal + temps (NOM_FICHIER_tXX_chXX.tif)":
numberOfZDepth = len(arrayOfImages[channelNumber])
if numberOfZDepth > maxNumberOfZDepth:
maxNumberOfZDepth = numberOfZDepth
for zNumber in range(len(arrayOfImages[channelNumber])):
numberOfTime = len(arrayOfImages[channelNumber][zNumber])
if numberOfTime > maxNumberOfTimeStamps:
maxNumberOfTimeStamps = numberOfTime
if valeurSelectionTypeFichier == "1 fichier par canal et par profondeur (NOM_FICHIER_zXX_chXX.tif)":
numberOfZDepth = len(arrayOfImages[channelNumber])
if numberOfZDepth > maxNumberOfZDepth:
maxNumberOfZDepth = numberOfZDepth
if valeurSelectionTypeFichier == "1 fichier par canal et par profondeur + temps (NOM_FICHIER_tXX_zXX_chXX.tif)":
numberOfZDepth = len(arrayOfImages[channelNumber])
print(arrayOfImages[channelNumber])
if numberOfZDepth > maxNumberOfZDepth:
maxNumberOfZDepth = numberOfZDepth
for zNumber in range(len(arrayOfImages[channelNumber])):
print(arrayOfImages[channelNumber][zNumber])
numberOfTime = len(arrayOfImages[channelNumber][zNumber])
if numberOfTime > maxNumberOfTimeStamps:
maxNumberOfTimeStamps = numberOfTime
hyperStack = ImageStack()
#imageTitle = "HyperStack"
print("C: "+str(maxNumberOfChannels)+", Z: "+str(maxNumberOfZDepth)+", T: "+str(maxNumberOfTimeStamps))
for timeNumber in range(maxNumberOfTimeStamps):
for zDepthNumber in range(maxNumberOfZDepth):
for channelNumber in range(maxNumberOfChannels):
#print("Position: "+str(channelNumber)+", "+str(zDepthNumber)+", "+str(timeNumber))
currentImagePlus = arrayOfImages[channelNumber][zDepthNumber][timeNumber]
#print("ImagePlus: "+str(currentImagePlus))
currentImagePlus.setC(channelNumber)
currentImagePlus.setZ(zDepthNumber)
currentImagePlus.setT(timeNumber)
currentImageProcessor = currentImagePlus.getProcessor()
hyperStack.addSlice(currentImageProcessor)
hyperStackImagePlus = ImagePlus(imageTitle, hyperStack)
#hyperStackImagePlus.show()
if maxNumberOfChannels*maxNumberOfZDepth*maxNumberOfTimeStamps > 1:
converter = HyperStackConverter()
hyperStackImagePlus = converter.toHyperStack(hyperStackImagePlus, maxNumberOfChannels, maxNumberOfZDepth, maxNumberOfTimeStamps, valeurSelectionDisplayMode)
if valeurSelectionTypeFichier == "1 fichier par canal + temps (NOM_FICHIER_tXX_chXX.tif)":
hyperStackImagePlus = converter.toHyperStack(hyperStackImagePlus, maxNumberOfChannels, maxNumberOfTimeStamps, maxNumberOfZDepth, "xyctz", valeurSelectionDisplayMode);
return hyperStackImagePlus
def reListImagePluses(fileList, imageTitle, valeurSelectionDisplayMode, valeurSelectionTypeFichier):
listOfOrderedImagePluses = []
hyperStackList = []
print("reListImagePluses - fileList: "+str(fileList))
if valeurSelectionTypeFichier == "1 fichier par canal (NOM_FICHIER_chXX.tif)":
channelsList = []
channelNumber = 0
for channelImagePlus in fileList:
imageWidth = channelImagePlus.getWidth(); #Largeur de l'image
imageHeight = channelImagePlus.getHeight(); #Hauteur de l'image
zDepthByChannel = channelImagePlus.getNSlices() #Profondeur Z
bitDepth = channelImagePlus.getBitDepth() #Type de l'image en bits - Returns the bit depth, 8, 16, 24 (RGB) or 32, or 0 if the bit depth is unknown. RGB images actually use 32 bits per pixel.
stackedImages = channelImagePlus.getStack()
arrayOfImages = []
for zNumber in range(1,zDepthByChannel+1):
currentImageProcessor = stackedImages.getProcessor(zNumber)
timeArray = []
for timeNumber in range(1):
if bitDepth == 8:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber), "8-bit Black", imageWidth, imageHeight, 1)
if bitDepth == 16:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber), "16-bit Black", imageWidth, imageHeight, 1)
if bitDepth == 24: #RGB[img["Channel 1, Z-Depth 1" (-658), 16-bit, 840x840x1x1x1]]
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber), "RGB Black", imageWidth, imageHeight, 1)
if bitDepth == 32:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber), "32-bit Black", imageWidth, imageHeight, 1)
newImage.setProcessor(currentImageProcessor)
timeArray.append(newImage)
arrayOfImages.append(timeArray)
channelsList.append(arrayOfImages)
channelNumber+=1
hyperStackImagePlus = assembleChannelImagesInStacks(imageTitle, channelsList, valeurSelectionDisplayMode, valeurSelectionTypeFichier)
hyperStackList.append(hyperStackImagePlus)
if valeurSelectionTypeFichier == "1 fichier par canal + temps (NOM_FICHIER_tXX_chXX.tif)":
channelsList = []
channelNumber = 0
for channelList in fileList:
timeArray = []
timeNumber = 0
for timeImagePlus in channelList:
imageWidth = timeImagePlus.getWidth(); #Largeur de l'image
imageHeight = timeImagePlus.getHeight(); #Hauteur de l'image
zDepthByChannel = timeImagePlus.getNSlices() #Profondeur Z
bitDepth = timeImagePlus.getBitDepth() #Type de l'image en bits - Returns the bit depth, 8, 16, 24 (RGB) or 32, or 0 if the bit depth is unknown. RGB images actually use 32 bits per pixel.
stackedImages = timeImagePlus.getStack()
arrayOfZDepths = []
for zNumber in range(1,zDepthByChannel+1):
currentImageProcessor = stackedImages.getProcessor(zNumber)
if bitDepth == 8:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber)+", T-time "+str(timeNumber), "8-bit Black", imageWidth, imageHeight, 1)
if bitDepth == 16:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber)+", T-time "+str(timeNumber), "16-bit Black", imageWidth, imageHeight, 1)
if bitDepth == 24: #RGB[img["Channel 1, Z-Depth 1" (-658), 16-bit, 840x840x1x1x1]]
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber)+", T-time "+str(timeNumber), "RGB Black", imageWidth, imageHeight, 1)
if bitDepth == 32:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber)+", T-time "+str(timeNumber), "32-bit Black", imageWidth, imageHeight, 1)
newImage.setProcessor(currentImageProcessor)
arrayOfZDepths.append(newImage)
timeNumber+=1
timeArray.append(arrayOfZDepths)
channelNumber+=1
channelsList.append(timeArray)
hyperStackImagePlus = assembleChannelImagesInStacks(imageTitle, channelsList, valeurSelectionDisplayMode, valeurSelectionTypeFichier)
hyperStackList.append(hyperStackImagePlus)
if valeurSelectionTypeFichier == "1 fichier par canal et par profondeur (NOM_FICHIER_zXX_chXX.tif)":
channelNumber = 0
channelsList = []
for channelList in fileList:
zDepthArray = []
zNumber = 1
for zDepthImagePlus in channelList:
timeArray = []
for timeNumber in range(1):
imageWidth = zDepthImagePlus.getWidth(); #Largeur de l'image
imageHeight = zDepthImagePlus.getHeight(); #Hauteur de l'image
bitDepth = zDepthImagePlus.getBitDepth() #Type de l'image en bits - Returns the bit depth, 8, 16, 24 (RGB) or 32, or 0 if the bit depth is unknown. RGB images actually use 32 bits per pixel.
currentImageProcessor = zDepthImagePlus.getProcessor()
if bitDepth == 8:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber), "8-bit Black", imageWidth, imageHeight, 1)
if bitDepth == 16:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber), "16-bit Black", imageWidth, imageHeight, 1)
if bitDepth == 24: #RGB[img["Channel 1, Z-Depth 1" (-658), 16-bit, 840x840x1x1x1]]
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber), "RGB Black", imageWidth, imageHeight, 1)
if bitDepth == 32:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber), "32-bit Black", imageWidth, imageHeight, 1)
newImage.setProcessor(currentImageProcessor)
timeArray.append(newImage)
zNumber+=1
zDepthArray.append(timeArray)
channelNumber+=1
channelsList.append(zDepthArray)
hyperStackImagePlus = assembleChannelImagesInStacks(imageTitle, channelsList, valeurSelectionDisplayMode, valeurSelectionTypeFichier)
hyperStackList.append(hyperStackImagePlus)
if valeurSelectionTypeFichier == "1 fichier par canal et par profondeur + temps (NOM_FICHIER_tXX_zXX_chXX.tif)":
channelNumber = 0
channelsList = []
for channelList in fileList:
zDepthArray = []
zNumber = 1
for zDepthList in channelList:
timeArray = []
tTime = 1
for timeImagePlus in zDepthList:
imageWidth = timeImagePlus.getWidth(); #Largeur de l'image
imageHeight = timeImagePlus.getHeight(); #Hauteur de l'image
bitDepth = timeImagePlus.getBitDepth() #Type de l'image en bits - Returns the bit depth, 8, 16, 24 (RGB) or 32, or 0 if the bit depth is unknown. RGB images actually use 32 bits per pixel.
currentImageProcessor = timeImagePlus.getProcessor()
if bitDepth == 8:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber)+", T-time "+str(tTime), "8-bit Black", imageWidth, imageHeight, 1)
if bitDepth == 16:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber)+", T-time "+str(tTime), "16-bit Black", imageWidth, imageHeight, 1)
if bitDepth == 24: #RGB[img["Channel 1, Z-Depth 1" (-658), 16-bit, 840x840x1x1x1]]
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber)+", T-time "+str(tTime), "RGB Black", imageWidth, imageHeight, 1)
if bitDepth == 32:
newImage = IJ.createImage(str(imageTitle)+" | Channel "+str(channelNumber)+", Z-Depth "+str(zNumber)+", T-time "+str(tTime), "32-bit Black", imageWidth, imageHeight, 1)
tTime+=1
newImage.setProcessor(currentImageProcessor)
timeArray.append(newImage)
zNumber+=1
zDepthArray.append(timeArray)
channelNumber+=1
channelsList.append(zDepthArray)
hyperStackImagePlus = assembleChannelImagesInStacks(imageTitle, channelsList, valeurSelectionDisplayMode, valeurSelectionTypeFichier)
hyperStackList.append(hyperStackImagePlus)
return hyperStackList
def openImageFile(folder, imageFile):
folder = folder.decode('utf8')
imageFile = imageFile.decode('utf8')
imagePath = str(folder)+"/"+str(imageFile)
reader, options = readImageFile(imagePath)
seriesCount = reader.getSeriesCount() #Nombre de séries
zDepthByChannel = reader.getSizeZ() #Profondeur Z
#imageStackImps = BF.openImagePlus(options)
seriesOfImageFile = []
for numberSerie in range(seriesCount):
options.setSeriesOn(numberSerie,True); #Pour LIF - compter les séries - https://gist.github.com/ctrueden/6282856
imageStackImps = BF.openImagePlus(options);
#print imageStackImps
mainImageStackImp = imageStackImps[-1] #0
mainImageStackImp.setTitle(str(imageFile)+"_"+str(numberSerie))
seriesOfImageFile.append(mainImageStackImp)
#return mainImageStackImp
return seriesOfImageFile
def readImageFile(imageFile):
#IJ.log(imageFile)
#print(imageFile)
extension = imageFile.split('.').pop() #Array.pop(). Pratique pour faire une fonction getExtension()
options = ImporterOptions()
options.setId(imageFile)
if extension == "nd":
reader = MetamorphReader()
else:
reader = ImageReader()
reader.setId(imageFile)
return reader, options
def saveFileImage(imagePlus, dumpSaveFilePath, dumpFileName):
fileSaver = FileSaver(imagePlus)
imageName = imagePlus.getTitle()
#File.makeDirectory(dumpDirectory)
dumpFileString = str(dumpSaveFilePath)+"/"+str(imageName)+"_"+str(dumpFileName)
#filestring=File.openAsString(dumpFileString);
#dumpFileString = str(dumpDirectory)
#fileSaver.saveAsTiff(dumpFileString)
#IJ.saveAsTiff(imagePlus,dumpFileString)
IJ.saveAs(imagePlus, "Tiff", dumpFileString);
# ok = False
# if (imagePlus.getStackSize() > 1):
# ok = fileSaver.saveAsTiffStack(imagePlus.getTitle());
# else:
# ok = fileSaver.saveAsTiff(imagePlus.getTitle());
# #The following call throws a NoSuchMethodError.
# #ok = IJ.saveAsTiff(imp, settings.imageFilename);
# if (ok==False):
# IJ.log("Failed to save image to file: " + imagePlus.getTitle());
###MAIN###
def run_script():
IJ.log('\\Clear') #efface le contenu de la console
your_os = System.getProperty("os.name");
print(your_os)
folder, dumpSaveFilePath, valeurSelectionTypeFichier, valeurSelectionDisplayMode = openMainDialogBox()
if folder is None or dumpSaveFilePath is None or valeurSelectionDisplayMode is None:
print("Cancel, End of Script")
return
if your_os == "Windows" or your_os == "Windows 10":
separator = "\\"
elif your_os == "Unix" or your_os == "Linux" or your_os == "Mac OS X":
separator = "/"
fileItems = getDirectoryContent(folder, valeurSelectionTypeFichier)
print("fileItems: "+str(fileItems))
for fileDirectory in fileItems:
for mainFileName in fileDirectory.keys():
imageTitle = str(mainFileName)
impList = fileDirectory[imageTitle]
listOfOrderedImagePluses = reListImagePluses(impList, imageTitle, valeurSelectionDisplayMode, valeurSelectionTypeFichier)
print("listOfOrderedImagePluses: "+str(listOfOrderedImagePluses))
for listedImagePlus in listOfOrderedImagePluses:
saveFileImage(listedImagePlus, dumpSaveFilePath, valeurSelectionDisplayMode)
print("End")
# If a Jython script is run, the variable __name__ contains the string '__main__'.
# If a script is loaded as module, __name__ has a different value.
if __name__ in ['__builtin__','__main__']:
run_script()