Examples with PositiveInteger ome.xml.model.primitives.PositiveInteger used on opensource projects

Example 26 with PositiveInteger

use of ome.xml.model.primitives.PositiveInteger in project bioformats by openmicroscopy.

the class BaseModelMock method makeImage.

private Image makeImage(int index) {
    // Create <Image/>
    Image image = new Image();
    image.setID("Image:" + index);
    // Create <Pixels/>
    Pixels pixels = new Pixels();
    pixels.setID("Pixels:" + index);
    pixels.setSizeX(new PositiveInteger(SIZE_X));
    pixels.setSizeY(new PositiveInteger(SIZE_Y));
    pixels.setSizeZ(new PositiveInteger(SIZE_Z));
    pixels.setSizeC(new PositiveInteger(SIZE_C));
    pixels.setSizeT(new PositiveInteger(SIZE_T));
    pixels.setDimensionOrder(DIMENSION_ORDER);
    pixels.setType(PIXEL_TYPE);
    // Create <BinData/>
    for (int i = 0; i < SIZE_Z * SIZE_C * SIZE_T; i++) {
        BinData binData = new BinData();
        binData.setBigEndian(false);
        binData.setCompression(Compression.NONE);
        binData.setLength(new NonNegativeLong((long) (SIZE_X * SIZE_Y * BYTES_PER_PIXEL)));
        pixels.addBinData(binData);
    }
    // Create <Channel/> under <Pixels/>
    for (int i = 0; i < SIZE_C; i++) {
        Channel channel = new Channel();
        channel.setID("Channel:" + i);
        pixels.addChannel(channel);
    }
    // Put <Pixels/> under <Image/>
    image.setPixels(pixels);
    return image;
}

Example 27 with PositiveInteger

use of ome.xml.model.primitives.PositiveInteger in project digilib by robcast.

the class BioFormatsDocuImage method writeImage.

@Override
public void writeImage(String mt, OutputStream ostream) throws ImageOpException, FileOpException {
    logger.debug("writeImage");
    File outFile;
    String filext = ".jpg";
    if (mt.equals("image/png")) {
        filext = ".png";
    }
    try {
        outFile = File.createTempFile("biof_temp", filext);
    } catch (IOException e) {
        throw new FileOpException(e.toString());
    }
    // save image to file
    ImageWriter iw = new ImageWriter();
    /*
         * try { //iw.setMetadataRetrieve(new DummyMetadata());
         * //iw.setSeries(0); //iw.setId(outFile.getAbsolutePath());
         * //logger.debug("writer="+iw); } catch (FormatException e) { throw new
         * FileOpException(e.toString()); } catch (IOException e) { // TODO
         * Auto-generated catch block e.printStackTrace(); } /* if
         * (mt.endsWith("png")) { iw = }
         */
    BufferedImageWriter writer = BufferedImageWriter.makeBufferedImageWriter(iw);
    try {
        logger.debug("setting metadata " + meta);
        iw.setMetadataRetrieve(meta);
        logger.debug("writing to file  " + outFile);
        writer.setId(outFile.getAbsolutePath());
        logger.debug("fixing metadata " + meta);
        iw.setInterleaved(reader.isInterleaved());
        iw.setWriteSequentially(true);
        meta.setPixelsSizeX(new PositiveInteger(img.getWidth()), 0);
        meta.setPixelsSizeY(new PositiveInteger(img.getHeight()), 0);
        meta.setPixelsSizeC(new PositiveInteger(img.getColorModel().getNumComponents()), 0);
        logger.debug("saving image " + img);
        writer.saveImage(0, img);
        logger.debug("closing file");
        writer.close();
    } catch (FormatException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    } catch (IOException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
    // now send file
    FileInputStream inFile = null;
    try {
        inFile = new FileInputStream(outFile);
        byte[] dataBuffer = new byte[4096];
        int len;
        while ((len = inFile.read(dataBuffer)) != -1) {
            // copy out file
            ostream.write(dataBuffer, 0, len);
        }
    } catch (IOException e) {
        throw new FileOpException(e.toString());
    } finally {
        try {
            if (inFile != null) {
                inFile.close();
            }
        } catch (IOException e) {
        // nothing to do
        }
    }
}

Example 28 with PositiveInteger

use of ome.xml.model.primitives.PositiveInteger 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);
    }
}

Example 29 with PositiveInteger

use of ome.xml.model.primitives.PositiveInteger in project bioformats by openmicroscopy.

the class MetadataTools method populatePixels.

/**
 * Populates the Pixels element of the given metadata store, using core
 * metadata from the given reader.  If the {@code doPlane} flag is set,
 * then the Plane elements will be populated as well. If the
 * {@code doImageName} flag is set, then the image name will be populated as
 * well.
 *
 * @param store       The metadata store whose Pixels should be populated
 * @param r           The format reader whose core metadata should be used
 * @param doPlane     Specifies whether Plane elements should be populated
 * @param doImageName Specifies whether the Image name should be populated
 */
public static void populatePixels(MetadataStore store, IFormatReader r, boolean doPlane, boolean doImageName) {
    if (store == null || r == null)
        return;
    int oldSeries = r.getSeries();
    for (int i = 0; i < r.getSeriesCount(); i++) {
        r.setSeries(i);
        String imageName = null;
        if (doImageName) {
            Location f = new Location(r.getCurrentFile());
            imageName = f.getName();
            if (r.getSeriesCount() > 1) {
                imageName += " #" + (i + 1);
            }
        }
        String pixelType = FormatTools.getPixelTypeString(r.getPixelType());
        populateMetadata(store, r.getCurrentFile(), i, imageName, r.isLittleEndian(), r.getDimensionOrder(), pixelType, r.getSizeX(), r.getSizeY(), r.getSizeZ(), r.getSizeC(), r.getSizeT(), r.getRGBChannelCount());
        store.setPixelsInterleaved(r.isInterleaved(), i);
        store.setPixelsSignificantBits(new PositiveInteger(r.getBitsPerPixel()), i);
        try {
            OMEXMLService service = new ServiceFactory().getInstance(OMEXMLService.class);
            if (service.isOMEXMLRoot(store.getRoot())) {
                MetadataStore baseStore = r.getMetadataStore();
                if (service.isOMEXMLMetadata(baseStore)) {
                    OMEXMLMetadata omeMeta;
                    try {
                        omeMeta = service.getOMEMetadata(service.asRetrieve(baseStore));
                        if (omeMeta.getTiffDataCount(i) == 0 && omeMeta.getPixelsBinDataCount(i) == 0) {
                            service.addMetadataOnly(omeMeta, i, i == 0);
                        }
                    } catch (ServiceException e) {
                        LOGGER.warn("Failed to add MetadataOnly", e);
                    }
                }
            }
        } catch (DependencyException exc) {
            LOGGER.warn("Failed to add MetadataOnly", exc);
        }
        if (doPlane) {
            for (int q = 0; q < r.getImageCount(); q++) {
                int[] coords = r.getZCTCoords(q);
                store.setPlaneTheZ(new NonNegativeInteger(coords[0]), i, q);
                store.setPlaneTheC(new NonNegativeInteger(coords[1]), i, q);
                store.setPlaneTheT(new NonNegativeInteger(coords[2]), i, q);
            }
        }
    }
    r.setSeries(oldSeries);
}

Example 30 with PositiveInteger

use of ome.xml.model.primitives.PositiveInteger in project bioformats by openmicroscopy.

the class FormatWriter method checkParams.

// -- Helper methods --
/**
 * Ensure that the arguments that are being passed to saveBytes(...) are
 * valid.
 * @throws FormatException if any of the arguments is invalid.
 */
protected void checkParams(int no, byte[] buf, int x, int y, int w, int h) throws FormatException {
    MetadataRetrieve r = getMetadataRetrieve();
    MetadataTools.verifyMinimumPopulated(r, series);
    if (buf == null)
        throw new FormatException("Buffer cannot be null.");
    int z = r.getPixelsSizeZ(series).getValue().intValue();
    int t = r.getPixelsSizeT(series).getValue().intValue();
    int c = r.getChannelCount(series);
    int planes = z * c * t;
    if (no < 0)
        throw new FormatException(String.format("Plane index:%d must be >= 0", no));
    if (no >= planes) {
        throw new FormatException(String.format("Plane index:%d must be < %d", no, planes));
    }
    int sizeX = r.getPixelsSizeX(series).getValue().intValue();
    int sizeY = r.getPixelsSizeY(series).getValue().intValue();
    if (x < 0)
        throw new FormatException(String.format("X:%d must be >= 0", x));
    if (y < 0)
        throw new FormatException(String.format("Y:%d must be >= 0", y));
    if (x >= sizeX) {
        throw new FormatException(String.format("X:%d must be < %d", x, sizeX));
    }
    if (y >= sizeY) {
        throw new FormatException(String.format("Y:%d must be < %d", y, sizeY));
    }
    if (w <= 0)
        throw new FormatException(String.format("Width:%d must be > 0", w));
    if (h <= 0)
        throw new FormatException(String.format("Height:%d must be > 0", h));
    if (x + w > sizeX)
        throw new FormatException(String.format("(w:%d + x:%d) must be <= %d", w, x, sizeX));
    if (y + h > sizeY)
        throw new FormatException(String.format("(h:%d + y:%d) must be <= %d", h, y, sizeY));
    int pixelType = FormatTools.pixelTypeFromString(r.getPixelsType(series).toString());
    int bpp = FormatTools.getBytesPerPixel(pixelType);
    PositiveInteger samples = r.getChannelSamplesPerPixel(series, 0);
    if (samples == null)
        samples = new PositiveInteger(1);
    int minSize = bpp * w * h * samples.getValue();
    if (buf.length < minSize) {
        throw new FormatException("Buffer is too small; expected " + minSize + " bytes, got " + buf.length + " bytes.");
    }
    if (!DataTools.containsValue(getPixelTypes(compression), pixelType)) {
        throw new FormatException("Unsupported image type '" + FormatTools.getPixelTypeString(pixelType) + "'.");
    }
}