use of loci.formats.IFormatWriter in project bioformats by openmicroscopy.
the class LosslessJPEG2000Test method setUp.
@BeforeMethod
public void setUp() throws Exception {
File temp8 = File.createTempFile("test", ".jp2");
File temp16 = File.createTempFile("test", ".jp2");
temp8.deleteOnExit();
temp16.deleteOnExit();
Location.mapId(FILE_8, temp8.getAbsolutePath());
Location.mapId(FILE_16, temp16.getAbsolutePath());
IMetadata metadata8;
try {
ServiceFactory factory = new ServiceFactory();
OMEXMLService service = factory.getInstance(OMEXMLService.class);
metadata8 = service.createOMEXMLMetadata();
} catch (DependencyException exc) {
throw new FormatException("Could not create OME-XML store.", exc);
} catch (ServiceException exc) {
throw new FormatException("Could not create OME-XML store.", exc);
}
MetadataTools.populateMetadata(metadata8, 0, "foo", false, "XYCZT", "uint8", 1, 1, 1, 1, 1, 1);
IFormatWriter writer8 = new JPEG2000Writer();
writer8.setMetadataRetrieve(metadata8);
writer8.setId(FILE_8);
writer8.saveBytes(0, PIXELS_8);
writer8.close();
IMetadata metadata16;
try {
ServiceFactory factory = new ServiceFactory();
OMEXMLService service = factory.getInstance(OMEXMLService.class);
metadata16 = service.createOMEXMLMetadata();
} catch (DependencyException exc) {
throw new FormatException("Could not create OME-XML store.", exc);
} catch (ServiceException exc) {
throw new FormatException("Could not create OME-XML store.", exc);
}
MetadataTools.populateMetadata(metadata16, 0, "foo", false, "XYCZT", "uint16", 1, 1, 1, 1, 1, 1);
IFormatWriter writer16 = new JPEG2000Writer();
writer16.setMetadataRetrieve(metadata16);
writer16.setId(FILE_16);
writer16.saveBytes(0, PIXELS_16);
writer16.close();
}
use of loci.formats.IFormatWriter in project bioformats by openmicroscopy.
the class ImageConverter method testConvert.
// -- Utility methods --
/**
* A utility method for converting a file from the command line.
*/
public boolean testConvert(IFormatWriter writer, String[] args) throws FormatException, IOException {
nextOutputIndex.clear();
options.setValidate(validate);
writer.setMetadataOptions(options);
firstTile = true;
boolean success = parseArgs(args);
if (!success) {
return false;
}
if (printVersion) {
CommandLineTools.printVersion();
return true;
}
CommandLineTools.runUpgradeCheck(args);
if (in == null || out == null) {
printUsage();
return false;
}
if (new Location(out).exists()) {
if (overwrite == null) {
LOGGER.warn("Output file {} exists.", out);
LOGGER.warn("Do you want to overwrite it? ([y]/n)");
BufferedReader r = new BufferedReader(new InputStreamReader(System.in, Constants.ENCODING));
String choice = r.readLine().trim().toLowerCase();
overwrite = !choice.startsWith("n");
}
if (!overwrite) {
LOGGER.warn("Exiting; next time, please specify an output file that " + "does not exist.");
return false;
} else {
new Location(out).delete();
}
}
if (map != null)
Location.mapId(in, map);
long start = System.currentTimeMillis();
LOGGER.info(in);
reader = new ImageReader();
if (stitch) {
reader = new FileStitcher(reader);
Location f = new Location(in);
String pat = null;
if (!f.exists()) {
pat = in;
} else {
pat = FilePattern.findPattern(f);
}
if (pat != null)
in = pat;
}
if (separate)
reader = new ChannelSeparator(reader);
if (merge)
reader = new ChannelMerger(reader);
if (fill)
reader = new ChannelFiller(reader);
minMax = null;
if (autoscale) {
reader = new MinMaxCalculator(reader);
minMax = (MinMaxCalculator) reader;
}
reader.setMetadataOptions(options);
reader.setGroupFiles(group);
reader.setMetadataFiltered(true);
reader.setOriginalMetadataPopulated(true);
OMEXMLService service = null;
try {
ServiceFactory factory = new ServiceFactory();
service = factory.getInstance(OMEXMLService.class);
reader.setMetadataStore(service.createOMEXMLMetadata());
} catch (DependencyException de) {
throw new MissingLibraryException(OMEXMLServiceImpl.NO_OME_XML_MSG, de);
} catch (ServiceException se) {
throw new FormatException(se);
}
reader.setId(in);
MetadataStore store = reader.getMetadataStore();
MetadataTools.populatePixels(store, reader, false, false);
boolean dimensionsSet = true;
if (width == 0 || height == 0) {
// otherwise default to series 0
if (series >= 0) {
reader.setSeries(series);
}
width = reader.getSizeX();
height = reader.getSizeY();
dimensionsSet = false;
}
if (channel >= reader.getEffectiveSizeC()) {
throw new FormatException("Invalid channel '" + channel + "' (" + reader.getEffectiveSizeC() + " channels in source file)");
}
if (timepoint >= reader.getSizeT()) {
throw new FormatException("Invalid timepoint '" + timepoint + "' (" + reader.getSizeT() + " timepoints in source file)");
}
if (zSection >= reader.getSizeZ()) {
throw new FormatException("Invalid Z section '" + zSection + "' (" + reader.getSizeZ() + " Z sections in source file)");
}
if (store instanceof MetadataRetrieve) {
try {
String xml = service.getOMEXML(service.asRetrieve(store));
OMEXMLMetadataRoot root = (OMEXMLMetadataRoot) store.getRoot();
IMetadata meta = service.createOMEXMLMetadata(xml);
if (series >= 0) {
Image exportImage = new Image(root.getImage(series));
Pixels exportPixels = new Pixels(root.getImage(series).getPixels());
exportImage.setPixels(exportPixels);
OMEXMLMetadataRoot newRoot = (OMEXMLMetadataRoot) meta.getRoot();
while (newRoot.sizeOfImageList() > 0) {
newRoot.removeImage(newRoot.getImage(0));
}
newRoot.addImage(exportImage);
meta.setRoot(newRoot);
meta.setPixelsSizeX(new PositiveInteger(width), 0);
meta.setPixelsSizeY(new PositiveInteger(height), 0);
if (autoscale) {
store.setPixelsType(PixelType.UINT8, 0);
}
if (channel >= 0) {
meta.setPixelsSizeC(new PositiveInteger(1), 0);
}
if (zSection >= 0) {
meta.setPixelsSizeZ(new PositiveInteger(1), 0);
}
if (timepoint >= 0) {
meta.setPixelsSizeT(new PositiveInteger(1), 0);
}
writer.setMetadataRetrieve((MetadataRetrieve) meta);
} else {
for (int i = 0; i < reader.getSeriesCount(); i++) {
meta.setPixelsSizeX(new PositiveInteger(width), 0);
meta.setPixelsSizeY(new PositiveInteger(height), 0);
if (autoscale) {
store.setPixelsType(PixelType.UINT8, i);
}
if (channel >= 0) {
meta.setPixelsSizeC(new PositiveInteger(1), 0);
}
if (zSection >= 0) {
meta.setPixelsSizeZ(new PositiveInteger(1), 0);
}
if (timepoint >= 0) {
meta.setPixelsSizeT(new PositiveInteger(1), 0);
}
}
writer.setMetadataRetrieve((MetadataRetrieve) meta);
}
} catch (ServiceException e) {
throw new FormatException(e);
}
}
writer.setWriteSequentially(true);
if (writer instanceof TiffWriter) {
((TiffWriter) writer).setBigTiff(bigtiff);
} else if (writer instanceof ImageWriter) {
IFormatWriter w = ((ImageWriter) writer).getWriter(out);
if (w instanceof TiffWriter) {
((TiffWriter) w).setBigTiff(bigtiff);
}
}
String format = writer.getFormat();
LOGGER.info("[{}] -> {} [{}]", new Object[] { reader.getFormat(), out, format });
long mid = System.currentTimeMillis();
int total = 0;
int num = writer.canDoStacks() ? reader.getSeriesCount() : 1;
long read = 0, write = 0;
int first = series == -1 ? 0 : series;
int last = series == -1 ? num : series + 1;
long timeLastLogged = System.currentTimeMillis();
for (int q = first; q < last; q++) {
reader.setSeries(q);
firstTile = true;
if (!dimensionsSet) {
width = reader.getSizeX();
height = reader.getSizeY();
}
int writerSeries = series == -1 ? q : 0;
writer.setSeries(writerSeries);
writer.setInterleaved(reader.isInterleaved() && !autoscale);
writer.setValidBitsPerPixel(reader.getBitsPerPixel());
int numImages = writer.canDoStacks() ? reader.getImageCount() : 1;
int startPlane = (int) Math.max(0, firstPlane);
int endPlane = (int) Math.min(numImages, lastPlane);
numImages = endPlane - startPlane;
if (channel >= 0) {
numImages /= reader.getEffectiveSizeC();
}
if (zSection >= 0) {
numImages /= reader.getSizeZ();
}
if (timepoint >= 0) {
numImages /= reader.getSizeT();
}
total += numImages;
int count = 0;
for (int i = startPlane; i < endPlane; i++) {
int[] coords = reader.getZCTCoords(i);
if ((zSection >= 0 && coords[0] != zSection) || (channel >= 0 && coords[1] != channel) || (timepoint >= 0 && coords[2] != timepoint)) {
continue;
}
String outputName = FormatTools.getFilename(q, i, reader, out, zeroPadding);
if (outputName.equals(FormatTools.getTileFilename(0, 0, 0, outputName))) {
writer.setId(outputName);
if (compression != null)
writer.setCompression(compression);
} else {
int tileNum = outputName.indexOf(FormatTools.TILE_NUM);
int tileX = outputName.indexOf(FormatTools.TILE_X);
int tileY = outputName.indexOf(FormatTools.TILE_Y);
if (tileNum < 0 && (tileX < 0 || tileY < 0)) {
throw new FormatException("Invalid file name pattern; " + FormatTools.TILE_NUM + " or both of " + FormatTools.TILE_X + " and " + FormatTools.TILE_Y + " must be specified.");
}
}
int outputIndex = 0;
if (nextOutputIndex.containsKey(outputName)) {
outputIndex = nextOutputIndex.get(outputName);
}
long s = System.currentTimeMillis();
long m = convertPlane(writer, i, outputIndex, outputName);
long e = System.currentTimeMillis();
read += m - s;
write += e - m;
nextOutputIndex.put(outputName, outputIndex + 1);
if (i == endPlane - 1) {
nextOutputIndex.remove(outputName);
}
// log number of planes processed every second or so
if (count == numImages - 1 || (e - timeLastLogged) / 1000 > 0) {
int current = (count - startPlane) + 1;
int percent = 100 * current / numImages;
StringBuilder sb = new StringBuilder();
sb.append("\t");
int numSeries = last - first;
if (numSeries > 1) {
sb.append("Series ");
sb.append(q);
sb.append(": converted ");
} else
sb.append("Converted ");
LOGGER.info(sb.toString() + "{}/{} planes ({}%)", new Object[] { current, numImages, percent });
timeLastLogged = e;
}
count++;
}
}
writer.close();
long end = System.currentTimeMillis();
LOGGER.info("[done]");
// output timing results
float sec = (end - start) / 1000f;
long initial = mid - start;
float readAvg = (float) read / total;
float writeAvg = (float) write / total;
LOGGER.info("{}s elapsed ({}+{}ms per plane, {}ms overhead)", new Object[] { sec, readAvg, writeAvg, initial });
return true;
}
use of loci.formats.IFormatWriter in project bioformats by openmicroscopy.
the class ImageConverter method convertTilePlane.
/**
* Convert the specified plane as a set of tiles, using the specified writer.
* @param writer the {@link loci.formats.IFormatWriter} to use for writing the plane
* @param index the index of the plane to convert in the input file
* @param outputIndex the index of the plane to convert in the output file
* @param currentFile the file name or pattern being written to
* @return the time at which conversion started, in milliseconds
* @throws FormatException
* @throws IOException
*/
private long convertTilePlane(IFormatWriter writer, int index, int outputIndex, String currentFile) throws FormatException, IOException {
int w = reader.getOptimalTileWidth();
int h = reader.getOptimalTileHeight();
if (saveTileWidth > 0 && saveTileWidth <= width) {
w = saveTileWidth;
}
if (saveTileHeight > 0 && saveTileHeight <= height) {
h = saveTileHeight;
}
if (firstTile) {
LOGGER.info("Tile size = {} x {}", w, h);
firstTile = false;
}
int nXTiles = width / w;
int nYTiles = height / h;
if (nXTiles * w != width) {
nXTiles++;
}
if (nYTiles * h != height) {
nYTiles++;
}
IFD ifd = new IFD();
ifd.put(IFD.TILE_WIDTH, w);
ifd.put(IFD.TILE_LENGTH, h);
Long m = null;
for (int y = 0; y < nYTiles; y++) {
for (int x = 0; x < nXTiles; x++) {
int tileX = xCoordinate + x * w;
int tileY = yCoordinate + y * h;
int tileWidth = x < nXTiles - 1 ? w : width - (w * x);
int tileHeight = y < nYTiles - 1 ? h : height - (h * y);
byte[] buf = reader.openBytes(index, tileX, tileY, tileWidth, tileHeight);
String tileName = FormatTools.getTileFilename(x, y, y * nXTiles + x, currentFile);
if (!currentFile.equals(tileName)) {
int nTileRows = getTileRows(currentFile);
int nTileCols = getTileColumns(currentFile);
int sizeX = nTileCols == 1 ? width : tileWidth;
int sizeY = nTileRows == 1 ? height : tileHeight;
MetadataRetrieve retrieve = writer.getMetadataRetrieve();
if (retrieve instanceof MetadataStore) {
((MetadataStore) retrieve).setPixelsSizeX(new PositiveInteger(sizeX), reader.getSeries());
((MetadataStore) retrieve).setPixelsSizeY(new PositiveInteger(sizeY), reader.getSeries());
}
writer.close();
writer.setMetadataRetrieve(retrieve);
writer.setId(tileName);
if (compression != null)
writer.setCompression(compression);
outputIndex = 0;
if (nextOutputIndex.containsKey(tileName)) {
outputIndex = nextOutputIndex.get(tileName);
}
nextOutputIndex.put(tileName, outputIndex + 1);
if (nTileRows > 1) {
tileY = 0;
}
if (nTileCols > 1) {
tileX = 0;
}
}
autoscalePlane(buf, index);
applyLUT(writer);
if (m == null) {
m = System.currentTimeMillis();
}
if (writer instanceof TiffWriter) {
((TiffWriter) writer).saveBytes(outputIndex, buf, ifd, tileX, tileY, tileWidth, tileHeight);
} else if (writer instanceof ImageWriter) {
IFormatWriter baseWriter = ((ImageWriter) writer).getWriter(out);
if (baseWriter instanceof TiffWriter) {
((TiffWriter) baseWriter).saveBytes(outputIndex, buf, ifd, tileX, tileY, tileWidth, tileHeight);
}
}
}
}
return m;
}
use of loci.formats.IFormatWriter in project bioformats by openmicroscopy.
the class Exporter method run.
// -- Exporter API methods --
/**
* Executes the plugin.
*/
public void run() {
String outfile = null;
Boolean splitZ = null;
Boolean splitC = null;
Boolean splitT = null;
Boolean padded = null;
Boolean saveRoi = null;
String compression = null;
Boolean windowless = Boolean.FALSE;
if (plugin.arg != null) {
outfile = Macro.getValue(plugin.arg, "outfile", null);
String z = Macro.getValue(plugin.arg, "splitZ", null);
String c = Macro.getValue(plugin.arg, "splitC", null);
String t = Macro.getValue(plugin.arg, "splitT", null);
String zeroPad = Macro.getValue(plugin.arg, "padded", null);
String sr = Macro.getValue(plugin.arg, "saveRoi", null);
compression = Macro.getValue(plugin.arg, "compression", null);
String id = Macro.getValue(plugin.arg, "imageid", null);
splitZ = z == null ? null : Boolean.valueOf(z);
splitC = c == null ? null : Boolean.valueOf(c);
splitT = t == null ? null : Boolean.valueOf(t);
padded = zeroPad == null ? null : Boolean.valueOf(zeroPad);
saveRoi = sr == null ? null : Boolean.valueOf(sr);
if (id != null) {
try {
int imageID = Integer.parseInt(id);
ImagePlus plus = WindowManager.getImage(imageID);
if (plus != null)
imp = plus;
} catch (Exception e) {
// nothing to do, we use the current imagePlus
}
}
String w = Macro.getValue(plugin.arg, "windowless", null);
if (w != null) {
windowless = Boolean.valueOf(w);
}
plugin.arg = null;
}
if (outfile == null) {
String options = Macro.getOptions();
if (options != null) {
String save = Macro.getValue(options, "save", null);
if (save != null)
outfile = save;
}
}
// create a temporary file if window less
if (windowless && (outfile == null || outfile.length() == 0)) {
File tmp = null;
try {
String name = removeExtension(imp.getTitle());
String n = name + ".ome.tif";
tmp = File.createTempFile(name, ".ome.tif");
File p = tmp.getParentFile();
File[] list = p.listFiles();
// make sure we delete a previous tmp file with same name if any
if (list != null) {
File toDelete = null;
for (int i = 0; i < list.length; i++) {
if (list[i].getName().equals(n)) {
toDelete = list[i];
break;
}
}
if (toDelete != null) {
toDelete.delete();
}
}
outfile = new File(p, n).getAbsolutePath();
if (Recorder.record)
Recorder.recordPath("outputfile", outfile);
IJ.log("exporter outputfile " + outfile);
} catch (Exception e) {
// fall back to window mode.
} finally {
if (tmp != null)
tmp.delete();
}
}
File f = null;
if (outfile == null || outfile.length() == 0) {
// open a dialog prompting for the filename to save
// NB: Copied and adapted from ij.io.SaveDIalog.jSaveDispatchThread,
// so that the save dialog has a file filter for choosing output format.
String dir = null, name = null;
JFileChooser fc = GUITools.buildFileChooser(new ImageWriter(), false);
fc.setDialogTitle("Bio-Formats Exporter");
String defaultDir = OpenDialog.getDefaultDirectory();
if (defaultDir != null)
fc.setCurrentDirectory(new File(defaultDir));
// set OME-TIFF as the default output format
FileFilter[] ff = fc.getChoosableFileFilters();
FileFilter defaultFilter = null;
for (int i = 0; i < ff.length; i++) {
if (ff[i] instanceof ExtensionFileFilter) {
ExtensionFileFilter eff = (ExtensionFileFilter) ff[i];
if (i == 0 || eff.getExtension().equals("ome.tif")) {
defaultFilter = eff;
break;
}
}
}
if (defaultFilter != null)
fc.setFileFilter(defaultFilter);
int returnVal = fc.showSaveDialog(IJ.getInstance());
if (returnVal != JFileChooser.APPROVE_OPTION) {
Macro.abort();
return;
}
f = fc.getSelectedFile();
dir = fc.getCurrentDirectory().getPath() + File.separator;
name = fc.getName(f);
if (f.exists()) {
int ret = JOptionPane.showConfirmDialog(fc, "The file " + f.getName() + " already exists. \n" + "Would you like to replace it?", "Replace?", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
if (ret != JOptionPane.OK_OPTION)
f = null;
} else {
// ensure filename matches selected filter
FileFilter filter = fc.getFileFilter();
if (filter instanceof ExtensionFileFilter) {
ExtensionFileFilter eff = (ExtensionFileFilter) filter;
String[] ext = eff.getExtensions();
String lName = name.toLowerCase();
boolean hasExtension = false;
for (int i = 0; i < ext.length; i++) {
if (lName.endsWith("." + ext[i])) {
hasExtension = true;
break;
}
}
if (!hasExtension && ext.length > 0) {
// append chosen extension
name = name + "." + ext[0];
}
f = fc.getSelectedFile();
String filePath = f.getAbsolutePath();
if (!filePath.endsWith("." + ext[0])) {
f = new File(filePath + '.' + ext[0]);
}
if (f.exists()) {
int ret1 = JOptionPane.showConfirmDialog(fc, "The file " + f.getName() + " already exists. \n" + "Would you like to replace it?", "Replace?", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
if (ret1 != JOptionPane.OK_OPTION)
f = null;
}
}
}
if (f == null)
Macro.abort();
else {
// do some ImageJ bookkeeping
OpenDialog.setDefaultDirectory(dir);
if (Recorder.record)
Recorder.recordPath("save", dir + name);
}
if (dir == null || name == null)
return;
outfile = new File(dir, name).getAbsolutePath();
if (outfile == null)
return;
}
if (windowless) {
if (splitZ == null)
splitZ = Boolean.FALSE;
if (splitC == null)
splitC = Boolean.FALSE;
if (splitT == null)
splitT = Boolean.FALSE;
if (padded == null)
padded = Boolean.FALSE;
}
if (splitZ == null || splitC == null || splitT == null) {
// ask if we want to export multiple files
GenericDialog multiFile = new GenericDialog("Bio-Formats Exporter - Multiple Files");
multiFile.addCheckbox("Write_each_Z_section to a separate file", false);
multiFile.addCheckbox("Write_each_timepoint to a separate file", false);
multiFile.addCheckbox("Write_each_channel to a separate file", false);
multiFile.addCheckbox("Use zero padding for filename indexes", false);
multiFile.showDialog();
splitZ = multiFile.getNextBoolean();
splitT = multiFile.getNextBoolean();
splitC = multiFile.getNextBoolean();
padded = multiFile.getNextBoolean();
if (multiFile.wasCanceled())
return;
}
try (IFormatWriter w = new ImageWriter().getWriter(outfile)) {
int ptype = 0;
int channels = 1;
switch(imp.getType()) {
case ImagePlus.GRAY8:
case ImagePlus.COLOR_256:
ptype = FormatTools.UINT8;
break;
case ImagePlus.COLOR_RGB:
channels = 3;
ptype = FormatTools.UINT8;
break;
case ImagePlus.GRAY16:
ptype = FormatTools.UINT16;
break;
case ImagePlus.GRAY32:
ptype = FormatTools.FLOAT;
break;
}
String title = imp.getTitle();
w.setWriteSequentially(true);
FileInfo fi = imp.getOriginalFileInfo();
String xml = fi == null ? null : fi.description == null ? null : fi.description.indexOf("xml") == -1 ? null : fi.description;
OMEXMLService service = null;
IMetadata store = null;
try {
ServiceFactory factory = new ServiceFactory();
service = factory.getInstance(OMEXMLService.class);
store = service.createOMEXMLMetadata(xml);
} catch (DependencyException de) {
} catch (ServiceException se) {
}
if (store == null)
IJ.error("OME-XML Java library not found.");
OMEXMLMetadataRoot root = (OMEXMLMetadataRoot) store.getRoot();
if (root.sizeOfROIList() > 0) {
while (root.sizeOfROIList() > 0) {
ROI roi = root.getROI(0);
root.removeROI(roi);
}
store.setRoot(root);
}
if (xml == null) {
store.createRoot();
} else if (store.getImageCount() > 1) {
// the original dataset had multiple series
// we need to modify the IMetadata to represent the correct series
ArrayList<Integer> matchingSeries = new ArrayList<Integer>();
for (int series = 0; series < store.getImageCount(); series++) {
String type = store.getPixelsType(series).toString();
int pixelType = FormatTools.pixelTypeFromString(type);
if (pixelType == ptype) {
String imageName = store.getImageName(series);
if (title.indexOf(imageName) >= 0) {
matchingSeries.add(series);
}
}
}
int series = 0;
if (matchingSeries.size() > 1) {
for (int i = 0; i < matchingSeries.size(); i++) {
int index = matchingSeries.get(i);
String name = store.getImageName(index);
boolean valid = true;
for (int j = 0; j < matchingSeries.size(); j++) {
if (i != j) {
String compName = store.getImageName(matchingSeries.get(j));
if (compName.indexOf(name) >= 0) {
valid = false;
break;
}
}
}
if (valid) {
series = index;
break;
}
}
} else if (matchingSeries.size() == 1)
series = matchingSeries.get(0);
ome.xml.model.Image exportImage = root.getImage(series);
List<ome.xml.model.Image> allImages = root.copyImageList();
for (ome.xml.model.Image img : allImages) {
if (!img.equals(exportImage)) {
root.removeImage(img);
}
}
store.setRoot(root);
}
store.setPixelsSizeX(new PositiveInteger(imp.getWidth()), 0);
store.setPixelsSizeY(new PositiveInteger(imp.getHeight()), 0);
store.setPixelsSizeZ(new PositiveInteger(imp.getNSlices()), 0);
store.setPixelsSizeC(new PositiveInteger(channels * imp.getNChannels()), 0);
store.setPixelsSizeT(new PositiveInteger(imp.getNFrames()), 0);
if (store.getImageID(0) == null) {
store.setImageID(MetadataTools.createLSID("Image", 0), 0);
}
if (store.getPixelsID(0) == null) {
store.setPixelsID(MetadataTools.createLSID("Pixels", 0), 0);
}
// reset the pixel type, unless the only change is signedness
// this prevents problems if the user changed the bit depth of the image
boolean applyCalibrationFunction = false;
try {
int originalType = -1;
if (store.getPixelsType(0) != null) {
originalType = FormatTools.pixelTypeFromString(store.getPixelsType(0).toString());
}
if (ptype != originalType && (store.getPixelsType(0) == null || !FormatTools.isSigned(originalType) || FormatTools.getBytesPerPixel(originalType) != FormatTools.getBytesPerPixel(ptype))) {
store.setPixelsType(PixelType.fromString(FormatTools.getPixelTypeString(ptype)), 0);
} else if (FormatTools.isSigned(originalType)) {
applyCalibrationFunction = true;
}
} catch (EnumerationException e) {
}
if (store.getPixelsBinDataCount(0) == 0 || store.getPixelsBinDataBigEndian(0, 0) == null) {
store.setPixelsBinDataBigEndian(Boolean.FALSE, 0, 0);
}
if (store.getPixelsDimensionOrder(0) == null) {
try {
store.setPixelsDimensionOrder(DimensionOrder.fromString(ORDER), 0);
} catch (EnumerationException e) {
}
}
LUT[] luts = new LUT[imp.getNChannels()];
for (int c = 0; c < imp.getNChannels(); c++) {
if (c >= store.getChannelCount(0) || store.getChannelID(0, c) == null) {
String lsid = MetadataTools.createLSID("Channel", 0, c);
store.setChannelID(lsid, 0, c);
}
store.setChannelSamplesPerPixel(new PositiveInteger(channels), 0, 0);
if (imp instanceof CompositeImage) {
luts[c] = ((CompositeImage) imp).getChannelLut(c + 1);
}
}
Calibration cal = imp.getCalibration();
store.setPixelsPhysicalSizeX(FormatTools.getPhysicalSizeX(cal.pixelWidth), 0);
store.setPixelsPhysicalSizeY(FormatTools.getPhysicalSizeY(cal.pixelHeight), 0);
store.setPixelsPhysicalSizeZ(FormatTools.getPhysicalSizeZ(cal.pixelDepth), 0);
store.setPixelsTimeIncrement(new Time(new Double(cal.frameInterval), UNITS.SECOND), 0);
if (imp.getImageStackSize() != imp.getNChannels() * imp.getNSlices() * imp.getNFrames()) {
if (!windowless) {
IJ.showMessageWithCancel("Bio-Formats Exporter Warning", "The number of planes in the stack (" + imp.getImageStackSize() + ") does not match the number of expected planes (" + (imp.getNChannels() * imp.getNSlices() * imp.getNFrames()) + ")." + "\nIf you select 'OK', only " + imp.getImageStackSize() + " planes will be exported. If you wish to export all of the " + "planes,\nselect 'Cancel' and convert the Image5D window " + "to a stack.");
}
store.setPixelsSizeZ(new PositiveInteger(imp.getImageStackSize()), 0);
store.setPixelsSizeC(new PositiveInteger(1), 0);
store.setPixelsSizeT(new PositiveInteger(1), 0);
}
Object info = imp.getProperty("Info");
if (info != null) {
String imageInfo = info.toString();
if (imageInfo != null) {
String[] lines = imageInfo.split("\n");
for (String line : lines) {
int eq = line.lastIndexOf("=");
if (eq > 0) {
String key = line.substring(0, eq).trim();
String value = line.substring(eq + 1).trim();
if (key.endsWith("BitsPerPixel")) {
w.setValidBitsPerPixel(Integer.parseInt(value));
break;
}
}
}
}
}
// NB: Animation rate code copied from ij.plugin.Animator#doOptions().
final int rate;
if (cal.fps != 0.0) {
rate = (int) cal.fps;
} else if (cal.frameInterval != 0.0 && cal.getTimeUnit().equals("sec")) {
rate = (int) (1.0 / cal.frameInterval);
} else {
// NB: Code from ij.plugin.Animator#animationRate initializer.
// The value is 7 by default in ImageJ, so must be 7 here as well.
rate = (int) Prefs.getDouble(Prefs.FPS, 7.0);
}
if (rate > 0)
w.setFramesPerSecond(rate);
String[] outputFiles = new String[] { outfile };
int sizeZ = store.getPixelsSizeZ(0).getValue();
int sizeC = store.getPixelsSizeC(0).getValue();
int sizeT = store.getPixelsSizeT(0).getValue();
if (splitZ || splitC || splitT) {
int nFiles = 1;
if (splitZ) {
nFiles *= sizeZ;
}
if (splitC) {
nFiles *= sizeC;
}
if (splitT) {
nFiles *= sizeT;
}
outputFiles = new String[nFiles];
int dot = outfile.indexOf(".", outfile.lastIndexOf(File.separator));
String base = outfile.substring(0, dot);
String ext = outfile.substring(dot);
int nextFile = 0;
for (int z = 0; z < (splitZ ? sizeZ : 1); z++) {
for (int c = 0; c < (splitC ? sizeC : 1); c++) {
for (int t = 0; t < (splitT ? sizeT : 1); t++) {
int index = FormatTools.getIndex(ORDER, sizeZ, sizeC, sizeT, sizeZ * sizeC * sizeT, z, c, t);
String pattern = base + (splitZ ? "_Z%z" : "") + (splitC ? "_C%c" : "") + (splitT ? "_T%t" : "") + ext;
outputFiles[nextFile++] = FormatTools.getFilename(0, index, store, pattern, padded);
}
}
}
}
if (!w.getFormat().startsWith("OME")) {
if (splitZ) {
store.setPixelsSizeZ(new PositiveInteger(1), 0);
}
if (splitC) {
store.setPixelsSizeC(new PositiveInteger(1), 0);
}
if (splitT) {
store.setPixelsSizeT(new PositiveInteger(1), 0);
}
}
// prompt for options
String[] codecs = w.getCompressionTypes();
ImageProcessor proc = imp.getImageStack().getProcessor(1);
Image firstImage = proc.createImage();
firstImage = AWTImageTools.makeBuffered(firstImage, proc.getColorModel());
int thisType = AWTImageTools.getPixelType((BufferedImage) firstImage);
if (proc instanceof ColorProcessor) {
thisType = FormatTools.UINT8;
} else if (proc instanceof ShortProcessor) {
thisType = FormatTools.UINT16;
}
boolean notSupportedType = !w.isSupportedType(thisType);
if (notSupportedType) {
IJ.error("Pixel type (" + FormatTools.getPixelTypeString(thisType) + ") not supported by this format.");
return;
}
if (codecs != null && codecs.length > 1) {
boolean selected = false;
if (compression != null) {
for (int i = 0; i < codecs.length; i++) {
if (codecs[i].equals(compression)) {
selected = true;
break;
}
}
}
if (!selected && !windowless) {
GenericDialog gd = new GenericDialog("Bio-Formats Exporter Options");
gd.addChoice("Compression type: ", codecs, codecs[0]);
if (saveRoi != null) {
gd.addCheckbox("Export ROIs", saveRoi.booleanValue());
} else {
gd.addCheckbox("Export ROIs", true);
}
gd.showDialog();
saveRoi = gd.getNextBoolean();
if (gd.wasCanceled())
return;
compression = gd.getNextChoice();
}
}
boolean in = false;
if (outputFiles.length > 1) {
for (int i = 0; i < outputFiles.length; i++) {
if (new File(outputFiles[i]).exists()) {
in = true;
break;
}
}
}
if (in && !windowless) {
int ret1 = JOptionPane.showConfirmDialog(null, "Some files already exist. \n" + "Would you like to replace them?", "Replace?", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
if (ret1 != JOptionPane.OK_OPTION) {
return;
}
// Delete the files overwrite does not correctly work
for (int i = 0; i < outputFiles.length; i++) {
new File(outputFiles[i]).delete();
}
}
// delete the file.
if (f != null)
f.delete();
if (compression != null) {
w.setCompression(compression);
}
// Save ROI's
if (saveRoi != null && saveRoi.booleanValue()) {
ROIHandler.saveROIs(store);
}
w.setMetadataRetrieve(store);
// convert and save slices
int size = imp.getImageStackSize();
ImageStack is = imp.getImageStack();
boolean doStack = w.canDoStacks() && size > 1;
int start = doStack ? 0 : imp.getCurrentSlice() - 1;
int end = doStack ? size : start + 1;
boolean littleEndian = false;
if (w.getMetadataRetrieve().getPixelsBigEndian(0) != null) {
littleEndian = !w.getMetadataRetrieve().getPixelsBigEndian(0).booleanValue();
} else if (w.getMetadataRetrieve().getPixelsBinDataCount(0) == 0) {
littleEndian = !w.getMetadataRetrieve().getPixelsBinDataBigEndian(0, 0).booleanValue();
}
byte[] plane = null;
w.setInterleaved(false);
int[] no = new int[outputFiles.length];
for (int i = start; i < end; i++) {
if (doStack) {
BF.status(false, "Saving plane " + (i + 1) + "/" + size);
BF.progress(false, i, size);
} else
BF.status(false, "Saving image");
proc = is.getProcessor(i + 1);
if (proc instanceof RecordedImageProcessor) {
proc = ((RecordedImageProcessor) proc).getChild();
}
int x = proc.getWidth();
int y = proc.getHeight();
if (proc instanceof ByteProcessor) {
if (applyCalibrationFunction) {
// don't alter 'pixels' directly as that will
// affect the open ImagePlus
byte[] pixels = (byte[]) proc.getPixels();
plane = new byte[pixels.length];
float[] calibration = proc.getCalibrationTable();
for (int pixel = 0; pixel < pixels.length; pixel++) {
plane[pixel] = (byte) calibration[pixels[pixel] & 0xff];
}
} else {
plane = (byte[]) proc.getPixels();
}
} else if (proc instanceof ShortProcessor) {
short[] pixels = (short[]) proc.getPixels();
if (applyCalibrationFunction) {
// don't alter 'pixels' directly as that will
// affect the open ImagePlus
plane = new byte[pixels.length * 2];
float[] calibration = proc.getCalibrationTable();
for (int pixel = 0; pixel < pixels.length; pixel++) {
short v = (short) calibration[pixels[pixel] & 0xffff];
DataTools.unpackBytes(v, plane, pixel * 2, 2, littleEndian);
}
} else {
plane = DataTools.shortsToBytes(pixels, littleEndian);
}
} else if (proc instanceof FloatProcessor) {
plane = DataTools.floatsToBytes((float[]) proc.getPixels(), littleEndian);
} else if (proc instanceof ColorProcessor) {
byte[][] pix = new byte[3][x * y];
((ColorProcessor) proc).getRGB(pix[0], pix[1], pix[2]);
plane = new byte[3 * x * y];
System.arraycopy(pix[0], 0, plane, 0, x * y);
System.arraycopy(pix[1], 0, plane, x * y, x * y);
System.arraycopy(pix[2], 0, plane, 2 * x * y, x * y);
if (i == start) {
sizeC /= 3;
}
}
int fileIndex = 0;
if (doStack) {
int[] coords = FormatTools.getZCTCoords(ORDER, sizeZ, sizeC, sizeT, size, i);
int realZ = sizeZ;
int realC = sizeC;
int realT = sizeT;
if (!splitZ) {
coords[0] = 0;
realZ = 1;
}
if (!splitC) {
coords[1] = 0;
realC = 1;
}
if (!splitT) {
coords[2] = 0;
realT = 1;
}
fileIndex = FormatTools.getIndex(ORDER, realZ, realC, realT, realZ * realC * realT, coords[0], coords[1], coords[2]);
}
if (notSupportedType) {
IJ.error("Pixel type not supported by this format.");
} else {
w.changeOutputFile(outputFiles[fileIndex]);
int currentChannel = FormatTools.getZCTCoords(ORDER, sizeZ, sizeC, sizeT, imp.getStackSize(), i)[1];
if (luts[currentChannel] != null) {
// expand to 16-bit LUT if necessary
int bpp = FormatTools.getBytesPerPixel(thisType);
if (bpp == 1) {
w.setColorModel(luts[currentChannel]);
} else if (bpp == 2) {
int lutSize = luts[currentChannel].getMapSize();
byte[][] lut = new byte[3][lutSize];
luts[currentChannel].getReds(lut[0]);
luts[currentChannel].getGreens(lut[1]);
luts[currentChannel].getBlues(lut[2]);
short[][] newLut = new short[3][65536];
int bins = newLut[0].length / lut[0].length;
for (int c = 0; c < newLut.length; c++) {
for (int q = 0; q < newLut[c].length; q++) {
int index = q / bins;
newLut[c][q] = (short) ((lut[c][index] * lut[0].length) + (q % bins));
}
}
w.setColorModel(new Index16ColorModel(16, newLut[0].length, newLut, littleEndian));
}
} else if (!proc.isDefaultLut()) {
w.setColorModel(proc.getColorModel());
}
w.saveBytes(no[fileIndex]++, plane);
}
}
w.close();
} catch (FormatException e) {
WindowTools.reportException(e);
} catch (IOException e) {
WindowTools.reportException(e);
}
}
use of loci.formats.IFormatWriter in project bioformats by openmicroscopy.
the class PrintFormatTable method printSupportedFormats.
public static void printSupportedFormats(String[] args) {
PrintStyles printStyle = PrintStyles.TXT;
boolean usage = false;
if (args != null) {
for (int i = 0; i < args.length; i++) {
if (args[i].equals("-help"))
usage = true;
else if (args[i].equals("-xml"))
printStyle = PrintStyles.XML;
else if (args[i].equals("-html"))
printStyle = PrintStyles.HTML;
else if (args[i].equals("-txt"))
printStyle = PrintStyles.TXT;
else {
LOGGER.warn("unknown flag: {}; try -help for options", args[i]);
}
}
}
if (usage) {
LOGGER.info("Usage: formatlist [-html] [-txt] [-xml]");
LOGGER.info(" -html: show formats in an HTML table");
LOGGER.info(" -txt: show formats in plaintext (default)");
LOGGER.info(" -xml: show formats as XML data");
return;
}
LOGGER.info(getHeader(printStyle));
// retrieve all of the file format readers and writers
ImageReader baseReader = new ImageReader();
IFormatReader[] readers = baseReader.getReaders();
ImageWriter baseWriter = new ImageWriter();
IFormatWriter[] writers = baseWriter.getWriters();
for (int i = 0; i < readers.length; i++) {
String readerFormatName = readers[i].getFormat();
boolean read = true;
boolean write = false;
boolean wmp = false;
// check if there is a corresponding writer
IFormatWriter writer = null;
for (int j = 0; j < writers.length; j++) {
if (writers[j].getFormat().equals(readerFormatName)) {
writer = writers[j];
}
}
if (writer != null) {
write = true;
// written to a single file
if (writer.canDoStacks())
wmp = true;
}
String[] extensions = readers[i].getSuffixes();
StringBuilder ext = new StringBuilder();
for (int j = 0; j < extensions.length; j++) {
ext.append(extensions[j]);
if (j < extensions.length - 1) {
ext.append(", ");
}
}
// display information about the format
LOGGER.info(getFormatLine(printStyle, readerFormatName, read, write, wmp, ext.toString()));
}
LOGGER.info(getFooter(printStyle));
}
Aggregations