Examples with Origin org.vcell.util.Origin used on opensource projects

Example 36 with Origin

use of org.vcell.util.Origin in project vcell by virtualcell.

the class ClientRequestManager method createNewGeometryTasks.

public AsynchClientTask[] createNewGeometryTasks(final TopLevelWindowManager requester, final VCDocument.DocumentCreationInfo documentCreationInfo, final AsynchClientTask[] afterTasks, final String okButtonText) {
    if (!isImportGeometryType(documentCreationInfo)) {
        throw new IllegalArgumentException("Analytic geometry not implemented.");
    }
    final String IMPORT_SOURCE_NAME = "IMPORT_SOURCE_NAME";
    // Get image from file
    AsynchClientTask selectImageFileTask = new AsynchClientTask("select image file", AsynchClientTask.TASKTYPE_SWING_BLOCKING) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            File imageFile = DatabaseWindowManager.showFileChooserDialog(requester, null, getUserPreferences(), JFileChooser.FILES_AND_DIRECTORIES);
            hashTable.put("imageFile", imageFile);
            hashTable.put(IMPORT_SOURCE_NAME, "File: " + imageFile.getName());
        }
    };
    final String FDFOS = "FDFOS";
    final String INITIAL_ANNOTATION = "INITIAL_ANNOTATION";
    final String ORIG_IMAGE_SIZE_INFO = "ORIG_IMAGE_SIZE_INFO";
    final String NEW_IMAGE_SIZE_INFO = "NEW_IMAGE_SIZE_INFO";
    final String DIR_FILES = "DIR_FILES";
    final String FD_MESH = "FD_MESH";
    final String FD_MESHISIZE = "FD_MESHISIZE";
    final String FD_TIMEPOINTS = "FD_TIMEPOINTS";
    AsynchClientTask parseImageTask = new AsynchClientTask("read and parse image file", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

        @Override
        public void run(final Hashtable<String, Object> hashTable) throws Exception {
            final Component guiParent = (Component) hashTable.get(ClientRequestManager.GUI_PARENT);
            try {
                FieldDataFileOperationSpec fdfos = null;
                if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FIJI_IMAGEJ) {
                    hashTable.put("imageFile", ImageJHelper.vcellWantImage(getClientTaskStatusSupport(), "Image for new VCell geometry"));
                }
                if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_BLENDER) {
                    hashTable.put("imageFile", ImageJHelper.vcellWantSurface(getClientTaskStatusSupport(), "Image for new VCell geometry"));
                }
                if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FILE || documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FIJI_IMAGEJ || documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_BLENDER) {
                    File imageFile = (File) hashTable.get("imageFile");
                    if (imageFile == null) {
                        throw new Exception("No file selected");
                    }
                    if (ExtensionFilter.isMatchingExtension(imageFile, ".nrrd")) {
                        DataInputStream dis = null;
                        try {
                            dis = new DataInputStream(new BufferedInputStream(new FileInputStream(imageFile)));
                            int xsize = 1;
                            int ysize = 1;
                            int zsize = 1;
                            double xspace = 1.0;
                            double yspace = 1.0;
                            double zspace = 1.0;
                            NRRDTYPE type = null;
                            NRRDENCODING encoding = null;
                            int dimension = -1;
                            // read header lines
                            while (true) {
                                @SuppressWarnings("deprecation") String line = dis.readLine();
                                if (line == null || line.length() == 0) {
                                    break;
                                }
                                StringTokenizer stringTokenizer = new StringTokenizer(line, ": ");
                                String headerParam = stringTokenizer.nextToken();
                                // System.out.println(headerParam);
                                if (headerParam.equals("sizes")) {
                                    if (dimension != -1) {
                                        xsize = Integer.parseInt(stringTokenizer.nextToken());
                                        if (dimension >= 2) {
                                            ysize = Integer.parseInt(stringTokenizer.nextToken());
                                        }
                                        if (dimension >= 3) {
                                            zsize = Integer.parseInt(stringTokenizer.nextToken());
                                        }
                                        for (int i = 4; i < dimension; i++) {
                                            if (Integer.parseInt(stringTokenizer.nextToken()) != 1) {
                                                throw new Exception("Dimensions > 3 not supported");
                                            }
                                        }
                                    } else {
                                        throw new Exception("dimension expected to be set before reading sizes");
                                    }
                                } else if (headerParam.equals("spacings")) {
                                    if (dimension != -1) {
                                        xspace = Double.parseDouble(stringTokenizer.nextToken());
                                        if (dimension >= 2) {
                                            yspace = Double.parseDouble(stringTokenizer.nextToken());
                                        }
                                        if (dimension >= 3) {
                                            zspace = Double.parseDouble(stringTokenizer.nextToken());
                                        }
                                    // ignore other dimension spacings
                                    } else {
                                        throw new Exception("dimension expected to be set before reading spacings");
                                    }
                                } else if (headerParam.equals("type")) {
                                    String nextToken = stringTokenizer.nextToken();
                                    if (nextToken.equalsIgnoreCase("double")) {
                                        type = NRRDTYPE.DOUBLE;
                                    } else if (nextToken.equalsIgnoreCase("float")) {
                                        type = NRRDTYPE.FLOAT;
                                    } else if (nextToken.equalsIgnoreCase("unsigned")) {
                                        nextToken = stringTokenizer.nextToken();
                                        if (nextToken.equalsIgnoreCase("char")) {
                                            type = NRRDTYPE.UNSIGNEDCHAR;
                                        } else {
                                            throw new Exception("Unknown nrrd data type=" + nextToken);
                                        }
                                    } else {
                                        throw new Exception("Unknown nrrd data type=" + nextToken);
                                    }
                                } else if (headerParam.equals("dimension")) {
                                    dimension = Integer.parseInt(stringTokenizer.nextToken());
                                    if (dimension < 1) {
                                        throw new Exception("unexpected dimension=" + dimension);
                                    }
                                } else if (headerParam.equals("encoding")) {
                                    encoding = NRRDENCODING.valueOf(stringTokenizer.nextToken().toUpperCase());
                                }
                            }
                            BufferedInputStream bis = null;
                            if (encoding == NRRDENCODING.GZIP) {
                                dis.close();
                                bis = new BufferedInputStream(new FileInputStream(imageFile));
                                boolean bnewLine = false;
                                while (true) {
                                    int currentChar = bis.read();
                                    if (currentChar == '\n') {
                                        if (bnewLine) {
                                            // 2 newlines end header
                                            break;
                                        }
                                        bnewLine = true;
                                    } else {
                                        bnewLine = false;
                                    }
                                }
                                GZIPInputStream gzipInputStream = new GZIPInputStream(bis);
                                dis = new DataInputStream(gzipInputStream);
                            }
                            double[] data = new double[xsize * ysize * zsize];
                            double minValue = Double.POSITIVE_INFINITY;
                            double maxValue = Double.NEGATIVE_INFINITY;
                            for (int i = 0; i < data.length; i++) {
                                if (i % 262144 == 0) {
                                    if (getClientTaskStatusSupport() != null) {
                                        getClientTaskStatusSupport().setMessage("Reading " + encoding + " " + type + " NRRD data " + (((long) i * (long) 100) / (long) data.length) + " % done.");
                                    }
                                }
                                if (type == NRRDTYPE.DOUBLE) {
                                    data[i] = dis.readDouble();
                                } else if (type == NRRDTYPE.FLOAT) {
                                    data[i] = dis.readFloat();
                                } else if (type == NRRDTYPE.UNSIGNEDCHAR) {
                                    data[i] = dis.readUnsignedByte();
                                } else {
                                    throw new Exception("Unexpected data type=" + type.toString());
                                }
                                minValue = Math.min(minValue, data[i]);
                                maxValue = Math.max(maxValue, data[i]);
                            }
                            dis.close();
                            if (getClientTaskStatusSupport() != null) {
                                getClientTaskStatusSupport().setMessage("Scaling " + encoding + " " + type + " NRRD data.");
                            }
                            short[] dataToSegment = new short[data.length];
                            double scaleShort = Math.pow(2, Short.SIZE) - 1;
                            for (int i = 0; i < data.length; i++) {
                                dataToSegment[i] |= (int) ((data[i] - minValue) / (maxValue - minValue) * scaleShort);
                            }
                            fdfos = new FieldDataFileOperationSpec();
                            fdfos.origin = new Origin(0, 0, 0);
                            fdfos.extent = new Extent((xsize == 1 ? .5 : (xsize) * xspace), (ysize == 1 ? .5 : (ysize) * yspace), (zsize == 1 ? .5 : (zsize) * zspace));
                            fdfos.isize = new ISize(xsize, ysize, zsize);
                            fdfos.shortSpecData = new short[][][] { { dataToSegment } };
                        } finally {
                            if (dis != null) {
                                try {
                                    dis.close();
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                    } else if ((fdfos = createFDOSFromSurfaceFile(imageFile)) != null) {
                    // try surface file formats
                    // work already done at this point
                    } else {
                        File[] dirFiles = null;
                        ImageSizeInfo origImageSizeInfo = null;
                        if (imageFile.isDirectory()) {
                            dirFiles = imageFile.listFiles(new java.io.FileFilter() {

                                public boolean accept(File pathname) {
                                    // exclude windows Thumbs.db
                                    return pathname.isFile() && !pathname.isHidden();
                                }
                            });
                            if (dirFiles.length == 0) {
                                throw new Exception("No valid files in selected directory");
                            }
                            String fileExt0 = null;
                            for (int i = 0; i < dirFiles.length; i++) {
                                int lastDot = dirFiles[i].getName().lastIndexOf('.');
                                String fileExt = (lastDot != -1 ? dirFiles[i].getName().substring(lastDot) : null);
                                if (dirFiles[i].isDirectory()) {
                                    fileExt = "dir";
                                }
                                if (i == 0) {
                                    fileExt0 = fileExt;
                                } else if (!Compare.isEqualOrNull(fileExt, fileExt0)) {
                                    String result = DialogUtils.showWarningDialog(requester.getComponent(), "Files in '" + imageFile.getAbsolutePath() + "' have different name extensions, continue?", new String[] { "OK", "Cancel" }, "Cancel");
                                    if (!"OK".equals(result)) {
                                        throw UserCancelException.CANCEL_FILE_SELECTION;
                                    }
                                    break;
                                }
                            }
                            hashTable.put(IMPORT_SOURCE_NAME, "Directory: " + imageFile.getAbsolutePath());
                            origImageSizeInfo = ImageDatasetReaderService.getInstance().getImageDatasetReader().getImageSizeInfoForceZ(dirFiles[0].getAbsolutePath(), dirFiles.length);
                            if (dirFiles.length > 1) {
                                final String importZ = "Import Z-Sections";
                                final String cancelOption = "Cancel";
                                String result = DialogUtils.showWarningDialog(guiParent, "Import all files in directory '" + imageFile.getAbsolutePath() + "' as Z-Sections", new String[] { importZ, cancelOption }, importZ);
                                if (result.equals(cancelOption)) {
                                    throw UserCancelException.CANCEL_GENERIC;
                                }
                            }
                            hashTable.put(DIR_FILES, dirFiles);
                        } else {
                            origImageSizeInfo = ImageDatasetReaderService.getInstance().getImageDatasetReader().getImageSizeInfo(imageFile.getAbsolutePath());
                            hashTable.put(IMPORT_SOURCE_NAME, "File: " + imageFile.getAbsolutePath());
                        }
                        hashTable.put(ORIG_IMAGE_SIZE_INFO, origImageSizeInfo);
                        return;
                    }
                } else if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FIELDDATA) {
                    getClientTaskStatusSupport().setMessage("Reading data from VCell server.");
                    VCDocument.GeomFromFieldDataCreationInfo docInfo = (VCDocument.GeomFromFieldDataCreationInfo) documentCreationInfo;
                    PDEDataContext pdeDataContext = getMdiManager().getFieldDataWindowManager().getPDEDataContext(docInfo.getExternalDataID(), null);
                    ImageSizeInfo newImageSizeInfo = (ImageSizeInfo) hashTable.get(NEW_IMAGE_SIZE_INFO);
                    pdeDataContext.setVariableNameAndTime(docInfo.getVarName(), newImageSizeInfo.getTimePoints()[newImageSizeInfo.getSelectedTimeIndex()]);
                    double[] data = pdeDataContext.getDataValues();
                    hashTable.put(INITIAL_ANNOTATION, hashTable.get(IMPORT_SOURCE_NAME));
                    CartesianMesh mesh = (CartesianMesh) hashTable.get(FD_MESH);
                    ISize meshISize = (ISize) hashTable.get(FD_MESHISIZE);
                    double minValue = Double.POSITIVE_INFINITY;
                    double maxValue = Double.NEGATIVE_INFINITY;
                    for (int i = 0; i < data.length; i++) {
                        minValue = Math.min(minValue, data[i]);
                        maxValue = Math.max(maxValue, data[i]);
                    }
                    short[] dataToSegment = new short[data.length];
                    double scaleShort = Math.pow(2, Short.SIZE) - 1;
                    for (int i = 0; i < data.length; i++) {
                        dataToSegment[i] |= (int) ((data[i] - minValue) / (maxValue - minValue) * scaleShort);
                    }
                    fdfos = new FieldDataFileOperationSpec();
                    fdfos.origin = mesh.getOrigin();
                    fdfos.extent = mesh.getExtent();
                    fdfos.isize = meshISize;
                    fdfos.shortSpecData = new short[][][] { { dataToSegment } };
                } else if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FROM_SCRATCH) {
                    ISize isize = getISizeFromUser(guiParent, new ISize(256, 256, 8), "Enter # of pixels for  x,y,z (e.g. 3D{256,256,8}, 2D{256,256,1}, 1D{256,1,1})");
                    fdfos = new FieldDataFileOperationSpec();
                    fdfos.origin = new Origin(0, 0, 0);
                    fdfos.extent = new Extent(1, 1, 1);
                    fdfos.isize = isize;
                    hashTable.put(IMPORT_SOURCE_NAME, "Scratch: New Geometry");
                // final int SCRATCH_SIZE_LIMIT = 512*512*20;
                // if(isize.getXYZ() > (SCRATCH_SIZE_LIMIT)){
                // throw new Exception("Total pixels (x*y*z) cannot be >"+SCRATCH_SIZE_LIMIT+".");
                // }
                } else if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FROM_WORKSPACE_ANALYTIC) {
                    if (hashTable.get(ClientRequestManager.GEOM_FROM_WORKSPACE) != null) {
                        Geometry workspaceGeom = (Geometry) hashTable.get(ClientRequestManager.GEOM_FROM_WORKSPACE);
                        ISize defaultISize = workspaceGeom.getGeometrySpec().getDefaultSampledImageSize();
                        ISize isize = getISizeFromUser(guiParent, defaultISize, "Warning: converting analytic expression geometry into an image based geometry\nwill remove analytic expressions after new image is created.\n\n" + "Enter size (x,y,z) for new geometry image (e.g. " + defaultISize.getX() + "," + defaultISize.getY() + "," + defaultISize.getZ() + ")");
                        hashTable.put(IMPORT_SOURCE_NAME, "Workspace from Analytic Geometry");
                        VCImage img = workspaceGeom.getGeometrySpec().createSampledImage(isize);
                        Enumeration<SubVolume> enumSubvolume = workspaceGeom.getGeometrySpec().getAnalyticOrCSGSubVolumes();
                        ArrayList<VCPixelClass> vcPixelClassArrList = new ArrayList<VCPixelClass>();
                        while (enumSubvolume.hasMoreElements()) {
                            SubVolume subVolume = enumSubvolume.nextElement();
                            vcPixelClassArrList.add(new VCPixelClass(null, subVolume.getName(), subVolume.getHandle()));
                        }
                        if (vcPixelClassArrList.size() > img.getPixelClasses().length) {
                            String result = DialogUtils.showOKCancelWarningDialog(requester.getComponent(), null, "Warning: sampling size is too small to include all subvolumes.");
                            if (result == null || !result.equals(SimpleUserMessage.OPTION_OK)) {
                                throw UserCancelException.CANCEL_GENERIC;
                            }
                        }
                        hashTable.put(VCPIXELCLASSES, vcPixelClassArrList.toArray(new VCPixelClass[0]));
                        fdfos = createFDOSFromVCImage(img);
                    } else {
                        throw new Exception("Expecting image source for GEOM_OPTION_FROM_WORKSPACE_ANALYTIC");
                    }
                } else if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FROM_WORKSPACE_IMAGE) {
                    if (hashTable.get(ClientRequestManager.GEOM_FROM_WORKSPACE) != null) {
                        Geometry workspaceGeom = (Geometry) hashTable.get(ClientRequestManager.GEOM_FROM_WORKSPACE);
                        hashTable.put(IMPORT_SOURCE_NAME, "Workspace Image");
                        fdfos = createFDOSFromVCImage(workspaceGeom.getGeometrySpec().getImage());
                        if (workspaceGeom.getGeometrySpec().getImage().getDescription() != null) {
                            hashTable.put(INITIAL_ANNOTATION, workspaceGeom.getGeometrySpec().getImage().getDescription());
                        }
                        hashTable.put(VCPIXELCLASSES, workspaceGeom.getGeometrySpec().getImage().getPixelClasses());
                    } else {
                        throw new Exception("Expecting image source for GEOM_OPTION_FROM_WORKSPACE");
                    }
                }
                hashTable.put(FDFOS, fdfos);
            } catch (DataFormatException ex) {
                throw new Exception("Cannot read image file.\n" + ex.getMessage());
            }
        }
    };
    AsynchClientTask getFieldDataImageParams = new AsynchClientTask("Getting DB Image parameters...", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            VCDocument.GeomFromFieldDataCreationInfo docInfo = (VCDocument.GeomFromFieldDataCreationInfo) documentCreationInfo;
            PDEDataContext pdeDataContext = getMdiManager().getFieldDataWindowManager().getPDEDataContext(docInfo.getExternalDataID(), null);
            CartesianMesh mesh = pdeDataContext.getCartesianMesh();
            ISize meshISize = new ISize(mesh.getSizeX(), mesh.getSizeY(), mesh.getSizeZ());
            double[] timePoints = pdeDataContext.getTimePoints();
            hashTable.put(FD_MESH, mesh);
            hashTable.put(FD_MESHISIZE, meshISize);
            hashTable.put(FD_TIMEPOINTS, timePoints);
        }
    };
    AsynchClientTask queryImageResizeTask = new AsynchClientTask("Query File Image Resize...", AsynchClientTask.TASKTYPE_SWING_BLOCKING) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            String importSourceName = (String) hashTable.get(IMPORT_SOURCE_NAME);
            if ((ImageSizeInfo) hashTable.get(ORIG_IMAGE_SIZE_INFO) != null) {
                // from file
                ImageSizeInfo newImagesiSizeInfo = queryImageResize(requester.getComponent(), (ImageSizeInfo) hashTable.get(ORIG_IMAGE_SIZE_INFO), true);
                hashTable.put(NEW_IMAGE_SIZE_INFO, newImagesiSizeInfo);
            } else if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FIELDDATA) {
                // from fielddata
                VCDocument.GeomFromFieldDataCreationInfo docInfo = (VCDocument.GeomFromFieldDataCreationInfo) documentCreationInfo;
                double[] fieldDataTimes = (double[]) hashTable.get(FD_TIMEPOINTS);
                hashTable.remove(FD_TIMEPOINTS);
                ISize fieldDataISize = (ISize) hashTable.get(FD_MESHISIZE);
                ImageSizeInfo origImageSizeInfo = new ImageSizeInfo(importSourceName, fieldDataISize, 1, fieldDataTimes, null);
                ImageSizeInfo newImagesiSizeInfo = queryImageResize(requester.getComponent(), origImageSizeInfo, true);
                hashTable.put(NEW_IMAGE_SIZE_INFO, newImagesiSizeInfo);
                hashTable.put(IMPORT_SOURCE_NAME, "FieldData: " + docInfo.getExternalDataID().getName() + " varName=" + docInfo.getVarName() + " timeIndex=" + newImagesiSizeInfo.getTimePoints()[newImagesiSizeInfo.getSelectedTimeIndex()]);
            }
        }
    };
    AsynchClientTask importFileImageTask = new AsynchClientTask("Importing Image from File...", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FILE && hashTable.get(FDFOS) == null) {
                ImageSizeInfo origImageSizeInfo = (ImageSizeInfo) hashTable.get(ORIG_IMAGE_SIZE_INFO);
                ImageSizeInfo newImageSizeInfo = (ImageSizeInfo) hashTable.get(NEW_IMAGE_SIZE_INFO);
                File[] dirFiles = (File[]) hashTable.get(DIR_FILES);
                File imageFile = (File) hashTable.get("imageFile");
                FieldDataFileOperationSpec fdfos = null;
                boolean bMergeChannels = origImageSizeInfo.getNumChannels() != newImageSizeInfo.getNumChannels();
                ISize resize = (origImageSizeInfo.getiSize().compareEqual(newImageSizeInfo.getiSize()) ? null : newImageSizeInfo.getiSize());
                if (dirFiles != null) {
                    Arrays.sort(dirFiles, new Comparator<File>() {

                        public int compare(File o1, File o2) {
                            return o1.getName().compareToIgnoreCase(o2.getName());
                        }
                    });
                    hashTable.put(INITIAL_ANNOTATION, dirFiles[0].getAbsolutePath() + "\n.\n.\n.\n" + dirFiles[dirFiles.length - 1].getAbsolutePath());
                    short[][] dataToSegment = null;
                    ISize isize = null;
                    Origin origin = null;
                    Extent extent = null;
                    int sizeXY = 0;
                    ISize firstImageISize = null;
                    for (int i = 0; i < dirFiles.length; i++) {
                        ImageDataset[] imageDatasets = ImageDatasetReaderService.getInstance().getImageDatasetReader().readImageDatasetChannels(dirFiles[i].getAbsolutePath(), null, bMergeChannels, null, resize);
                        for (int c = 0; c < imageDatasets.length; c++) {
                            if (imageDatasets[c].getSizeZ() != 1 || imageDatasets[c].getSizeT() != 1) {
                                throwImportWholeDirectoryException(imageFile, dirFiles[i].getAbsolutePath() + " has Z=" + imageDatasets[c].getSizeZ() + " T=" + imageDatasets[c].getSizeT());
                            }
                            if (isize == null) {
                                firstImageISize = imageDatasets[c].getISize();
                                sizeXY = imageDatasets[c].getISize().getX() * imageDatasets[c].getISize().getY();
                                dataToSegment = new short[imageDatasets.length][sizeXY * dirFiles.length];
                                isize = new ISize(imageDatasets[c].getISize().getX(), imageDatasets[c].getISize().getY(), dirFiles.length);
                                origin = imageDatasets[c].getAllImages()[0].getOrigin();
                                extent = imageDatasets[c].getExtent();
                            }
                            if (!firstImageISize.compareEqual(imageDatasets[c].getISize())) {
                                throwImportWholeDirectoryException(imageFile, dirFiles[0].getAbsolutePath() + " " + firstImageISize + " does not equal " + dirFiles[i].getAbsolutePath() + " " + imageDatasets[c].getISize());
                            }
                            System.arraycopy(imageDatasets[c].getImage(0, 0, 0).getPixels(), 0, dataToSegment[c], sizeXY * i, sizeXY);
                        }
                    }
                    fdfos = new FieldDataFileOperationSpec();
                    fdfos.origin = origin;
                    fdfos.extent = extent;
                    fdfos.isize = isize;
                    fdfos.shortSpecData = new short[][][] { dataToSegment };
                } else {
                    hashTable.put(INITIAL_ANNOTATION, imageFile.getAbsolutePath());
                    Integer userPreferredTimeIndex = null;
                    if (origImageSizeInfo.getTimePoints().length > 1) {
                        userPreferredTimeIndex = newImageSizeInfo.getSelectedTimeIndex();
                    }
                    getClientTaskStatusSupport().setMessage("Reading file...");
                    ImageDataset[] imageDatasets = ImageDatasetReaderService.getInstance().getImageDatasetReader().readImageDatasetChannels(imageFile.getAbsolutePath(), null, bMergeChannels, userPreferredTimeIndex, resize);
                    fdfos = ClientRequestManager.createFDOSWithChannels(imageDatasets, null);
                }
                hashTable.put(FDFOS, fdfos);
                hashTable.remove(NEW_IMAGE_SIZE_INFO);
                hashTable.remove(ORIG_IMAGE_SIZE_INFO);
                hashTable.remove(DIR_FILES);
            }
        }
    };
    AsynchClientTask resizeImageTask = new AsynchClientTask("Resizing Image...", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            ImageSizeInfo newImageSizeInfo = (ImageSizeInfo) hashTable.get(NEW_IMAGE_SIZE_INFO);
            FieldDataFileOperationSpec fdfos = (FieldDataFileOperationSpec) hashTable.get(FDFOS);
            if (newImageSizeInfo != null && fdfos != null && !fdfos.isize.compareEqual(newImageSizeInfo.getiSize())) {
                resizeImage((FieldDataFileOperationSpec) hashTable.get(FDFOS), newImageSizeInfo.getiSize(), documentCreationInfo.getOption());
            }
        }
    };
    AsynchClientTask finishTask = new AsynchClientTask("Finishing...", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

        @Override
        public void run(final Hashtable<String, Object> hashTable) throws Exception {
            getClientTaskStatusSupport().setMessage("Initializing...");
            final ROIMultiPaintManager roiMultiPaintManager = new ROIMultiPaintManager();
            roiMultiPaintManager.initROIData((FieldDataFileOperationSpec) hashTable.get(FDFOS));
            final Geometry[] geomHolder = new Geometry[1];
            final VCPixelClass[] postProcessPixelClasses = (VCPixelClass[]) hashTable.get(VCPIXELCLASSES);
            AsynchClientTask task1 = new AsynchClientTask("edit geometry", AsynchClientTask.TASKTYPE_SWING_BLOCKING, false) {

                @Override
                public void run(Hashtable<String, Object> hashTable) throws Exception {
                    geomHolder[0] = roiMultiPaintManager.showGUI(okButtonText, (String) hashTable.get(IMPORT_SOURCE_NAME), (Component) hashTable.get(GUI_PARENT), (String) hashTable.get(INITIAL_ANNOTATION), postProcessPixelClasses, getUserPreferences());
                }
            };
            AsynchClientTask task2 = new AsynchClientTask("update geometry", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

                @Override
                public void run(Hashtable<String, Object> hashTable) throws Exception {
                    // Create default name for image
                    String dateTimeString = BeanUtils.generateDateTimeString();
                    geomHolder[0].getGeometrySpec().getImage().setName("img_" + dateTimeString);
                    geomHolder[0].setName("geom_" + dateTimeString);
                    // cause update in this thread so later swing threads won't be delayed
                    geomHolder[0].precomputeAll(new GeometryThumbnailImageFactoryAWT());
                    hashTable.put("doc", geomHolder[0]);
                }
            };
            AsynchClientTask[] finalTasks = afterTasks;
            if (finalTasks == null) {
                finalTasks = new AsynchClientTask[] { getSaveImageAndGeometryTask() };
            }
            AsynchClientTask[] tasks = new AsynchClientTask[2 + finalTasks.length];
            tasks[0] = task1;
            tasks[1] = task2;
            System.arraycopy(finalTasks, 0, tasks, 2, finalTasks.length);
            ClientTaskDispatcher.dispatch((Component) hashTable.get(GUI_PARENT), hashTable, tasks, false, false, null, true);
        }
    };
    Vector<AsynchClientTask> tasksV = new Vector<AsynchClientTask>();
    if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FROM_SCRATCH) {
        tasksV.addAll(Arrays.asList(new AsynchClientTask[] { parseImageTask, finishTask }));
    } else if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FROM_WORKSPACE_ANALYTIC) {
        tasksV.addAll(Arrays.asList(new AsynchClientTask[] { parseImageTask, finishTask }));
    } else if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FROM_WORKSPACE_IMAGE) {
        tasksV.addAll(Arrays.asList(new AsynchClientTask[] { parseImageTask, finishTask }));
    } else if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FILE) {
        tasksV.addAll(Arrays.asList(new AsynchClientTask[] { selectImageFileTask, parseImageTask, queryImageResizeTask, importFileImageTask, /*resizes*/
        finishTask }));
    } else if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FIJI_IMAGEJ || documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_BLENDER) {
        tasksV.addAll(Arrays.asList(new AsynchClientTask[] { parseImageTask, queryImageResizeTask, importFileImageTask, /*resizes*/
        finishTask }));
    } else if (documentCreationInfo.getOption() == VCDocument.GEOM_OPTION_FIELDDATA) {
        tasksV.addAll(Arrays.asList(new AsynchClientTask[] { getFieldDataImageParams, queryImageResizeTask, parseImageTask, resizeImageTask, finishTask }));
    }
    return tasksV.toArray(new AsynchClientTask[0]);
}

Example 37 with Origin

use of org.vcell.util.Origin in project vcell by virtualcell.

the class VCellClientDataServiceImpl method getSimsFromOpenModels.

@Override
public List<SimulationDataSetRef> getSimsFromOpenModels() {
    ArrayList<SimulationDataSetRef> simulationDataSetRefs = new ArrayList<SimulationDataSetRef>();
    for (TopLevelWindowManager windowManager : vcellClient.getMdiManager().getWindowManagers()) {
        Simulation[] simulations = null;
        VCDocument modelDocument = null;
        if (windowManager instanceof BioModelWindowManager) {
            BioModelWindowManager selectedBioWindowManager = (BioModelWindowManager) windowManager;
            BioModel bioModel = selectedBioWindowManager.getBioModel();
            simulations = bioModel.getSimulations();
            modelDocument = bioModel;
        // simOwnerCount = bioModel.getNumSimulationContexts();
        } else if (windowManager instanceof MathModelWindowManager) {
            MathModelWindowManager selectedMathWindowManager = (MathModelWindowManager) windowManager;
            MathModel mathModel = selectedMathWindowManager.getMathModel();
            simulations = mathModel.getSimulations();
            modelDocument = mathModel;
        // simOwnerCount = 1;
        }
        if (simulations != null) {
            for (Simulation simulation : simulations) {
                if (!isVtkSupported(simulation)) {
                    continue;
                }
                Origin origin = simulation.getMathDescription().getGeometry().getOrigin();
                Extent extent = simulation.getMathDescription().getGeometry().getExtent();
                SimulationInfo simInfo = simulation.getSimulationInfo();
                SimulationStatus simStatus = vcellClient.getRequestManager().getServerSimulationStatus(simInfo);
                for (int jobIndex = 0; jobIndex < simulation.getScanCount(); jobIndex++) {
                    if (simStatus != null && simStatus.getHasData()) {
                        SimulationDataSetRef simulationDataSetReference = VCellClientDataServiceImpl.createSimulationDataSetRef(simulation, modelDocument, jobIndex, false);
                        simulationDataSetRefs.add(simulationDataSetReference);
                    }
                }
            }
        }
    }
    File localSimDir = ResourceUtil.getLocalSimDir(User.tempUser.getName());
    String[] simtaskFilenames = localSimDir.list((dir, name) -> (name.endsWith(".simtask.xml")));
    for (String simtaskFilename : simtaskFilenames) {
        try {
            SimulationTask simTask = XmlHelper.XMLToSimTask(org.apache.commons.io.FileUtils.readFileToString(new File(localSimDir, simtaskFilename)));
            VCDocument modelDocument = null;
            SimulationDataSetRef simulationDataSetReference = VCellClientDataServiceImpl.createSimulationDataSetRef(simTask.getSimulation(), modelDocument, simTask.getSimulationJob().getJobIndex(), true);
            simulationDataSetRefs.add(simulationDataSetReference);
        } catch (ExpressionException | XmlParseException | IOException e) {
            e.printStackTrace();
        }
    }
    return simulationDataSetRefs;
}

Example 38 with Origin

use of org.vcell.util.Origin in project vcell by virtualcell.

the class ClientRequestManager method createFDOSWithChannels.

public static FieldDataFileOperationSpec createFDOSWithChannels(ImageDataset[] imagedataSets, Integer saveOnlyThisTimePointIndex) {
    final FieldDataFileOperationSpec fdos = new FieldDataFileOperationSpec();
    // [time][var][data]
    int numXY = imagedataSets[0].getISize().getX() * imagedataSets[0].getISize().getY();
    int numXYZ = imagedataSets[0].getSizeZ() * numXY;
    fdos.variableTypes = new VariableType[imagedataSets.length];
    fdos.varNames = new String[imagedataSets.length];
    short[][][] shortData = new short[(saveOnlyThisTimePointIndex != null ? 1 : imagedataSets[0].getSizeT())][imagedataSets.length][numXYZ];
    for (int c = 0; c < imagedataSets.length; c += 1) {
        fdos.variableTypes[c] = VariableType.VOLUME;
        fdos.varNames[c] = "Channel" + c;
        for (int t = 0; t < imagedataSets[c].getSizeT(); t += 1) {
            if (saveOnlyThisTimePointIndex != null && saveOnlyThisTimePointIndex.intValue() != t) {
                continue;
            }
            int zOffset = 0;
            for (int z = 0; z < imagedataSets[c].getSizeZ(); z += 1) {
                UShortImage ushortImage = imagedataSets[c].getImage(z, 0, t);
                System.arraycopy(ushortImage.getPixels(), 0, shortData[(saveOnlyThisTimePointIndex != null ? 0 : t)][c], zOffset, numXY);
                // shortData[t][c] = ushortImage.getPixels();
                zOffset += numXY;
            }
        }
    }
    fdos.shortSpecData = shortData;
    fdos.times = imagedataSets[0].getImageTimeStamps();
    if (fdos.times == null) {
        fdos.times = new double[imagedataSets[0].getSizeT()];
        for (int i = 0; i < fdos.times.length; i += 1) {
            fdos.times[i] = i;
        }
    }
    fdos.origin = (imagedataSets[0].getAllImages()[0].getOrigin() != null ? imagedataSets[0].getAllImages()[0].getOrigin() : new Origin(0, 0, 0));
    fdos.extent = (imagedataSets[0].getExtent() != null) ? (imagedataSets[0].getExtent()) : (new Extent(1, 1, 1));
    fdos.isize = imagedataSets[0].getISize();
    return fdos;
}

Example 39 with Origin

use of org.vcell.util.Origin in project vcell by virtualcell.

the class CartesianMeshChombo method readMeshFile.

public static CartesianMeshChombo readMeshFile(File chomboMeshFile) throws Exception {
    CartesianMeshChombo chomboMesh = new CartesianMeshChombo();
    if (H5.H5open() < 0) {
        throw new Exception("H5.H5open() failed");
    }
    FileFormat fileFormat = FileFormat.getFileFormat(FileFormat.FILE_TYPE_HDF5);
    if (fileFormat == null) {
        throw new Exception("FileFormat.getFileFormat(FileFormat.FILE_TYPE_HDF5) failed, returned null.");
    }
    FileFormat meshFile = null;
    try {
        meshFile = fileFormat.createInstance(chomboMeshFile.getAbsolutePath(), FileFormat.READ);
        meshFile.open();
        DefaultMutableTreeNode rootNode = (DefaultMutableTreeNode) meshFile.getRootNode();
        Group rootGroup = (Group) rootNode.getUserObject();
        Group meshGroup = (Group) rootGroup.getMemberList().get(0);
        List<Attribute> meshAttrList = meshGroup.getMetadata();
        for (Attribute attr : meshAttrList) {
            String attrName = attr.getName();
            MeshAttribute mattr = null;
            try {
                mattr = MeshAttribute.valueOf(attrName);
            } catch (IllegalArgumentException ex) {
            }
            if (mattr == null) {
                // if not found, then we don't care about this attribute
                logger.debug("mesh attribute " + attrName + " is not defined in Java");
                continue;
            }
            Object value = attr.getValue();
            switch(mattr) {
                case dimension:
                    chomboMesh.dimension = ((int[]) value)[0];
                    break;
                case numLevels:
                    chomboMesh.numLevels = ((int[]) value)[0];
                    break;
                case viewLevel:
                    chomboMesh.viewLevel = ((int[]) value)[0];
                    break;
                case refineRatios:
                    chomboMesh.refineRatios = (int[]) value;
                    break;
                case Dx:
                case extent:
                case Nx:
                case origin:
                    // these 4 has format of {};
                    String[] valueStrArray = (String[]) value;
                    String value0 = valueStrArray[0];
                    StringTokenizer st = new StringTokenizer(value0, "{,} ");
                    int numTokens = st.countTokens();
                    // we need 3 for 3d
                    double[] values = new double[Math.max(3, numTokens)];
                    for (int i = 0; i < Math.min(3, numTokens); ++i) {
                        String token = st.nextToken();
                        values[i] = Double.parseDouble(token);
                    }
                    switch(mattr) {
                        case Dx:
                            chomboMesh.dx = new double[3];
                            System.arraycopy(values, 0, chomboMesh.dx, 0, values.length);
                            break;
                        case extent:
                            chomboMesh.extent = new Extent(values[0], values[1], values[2] == 0 ? 1 : values[2]);
                            break;
                        case Nx:
                            chomboMesh.size = new ISize((int) values[0], (int) values[1], values[2] == 0 ? 1 : (int) values[2]);
                            break;
                        case origin:
                            chomboMesh.origin = new Origin(values[0], values[1], values[2]);
                            break;
                    }
                    break;
            }
        }
        List<HObject> memberList = meshGroup.getMemberList();
        for (HObject member : memberList) {
            if (!(member instanceof Dataset)) {
                continue;
            }
            Dataset dataset = (Dataset) member;
            Vector vectValues = (Vector) dataset.read();
            String name = dataset.getName();
            MeshDataSet mdataset = null;
            try {
                mdataset = MeshDataSet.valueOfName(name);
            } catch (IllegalArgumentException ex) {
                logger.debug("mesh dataset " + name + " is not defined in Java");
            }
            if (mdataset == null) {
                // if not found, then we don't care about this dataset
                continue;
            }
            switch(mdataset) {
                case vertices:
                    collectVertices(chomboMesh, vectValues);
                    break;
                case segments:
                    collect2dSegments(chomboMesh, vectValues);
                    break;
                case structures:
                    collectStructures(chomboMesh, vectValues);
                    break;
                case featurephasevols:
                    collectFeaturePhaseVols(chomboMesh, vectValues);
                    break;
                case membraneids:
                    collectMembraneIds(chomboMesh, vectValues);
                    break;
                case membrane_elements:
                case membrane_elements_old:
                    collectMembraneElements(chomboMesh, vectValues);
                    break;
                case surface_triangles:
                    collect3dSurfaceTriangles(chomboMesh, vectValues);
                    break;
                case slice_view:
                    collect3dSliceView(chomboMesh, vectValues);
                    break;
            }
        }
    } finally {
        if (meshFile != null) {
            meshFile.close();
        }
    }
    // set neighbors to membrane elements
    if (chomboMesh.dimension == 2 && chomboMesh.membraneElements != null) {
        for (int i = 0; i < chomboMesh.membraneElements.length; ++i) {
            MembraneElement me = chomboMesh.membraneElements[i];
            me.setConnectivity(chomboMesh.segments[i].prevNeigbhor, chomboMesh.segments[i].nextNeigbhor, -1, -1);
        }
    }
    return chomboMesh;
}

Example 40 with Origin

use of org.vcell.util.Origin in project vcell by virtualcell.

the class FunctionRangeGenerator method main.

public static void main(String[] args) {
    try {
        Expression exp = new Expression("a+log(b)+c");
        VarStatistics[] varStats = new VarStatistics[3];
        varStats[0] = new VarStatistics("a", new double[] { 1.0, 2.0, 3.0 }, new double[] { 1.0, 2.0, 3.0 });
        varStats[1] = new VarStatistics("b", new double[] { 1.0, 2.0, 3.0 }, new double[] { 1.0, 2.0, 3.0 });
        varStats[2] = new VarStatistics("c", new double[] { 1.0, 2.0, 3.0 }, new double[] { 1.0, 2.0, 3.0 });
        double[] times = new double[] { 0.0, 1.0, 2.0 };
        Extent extent = new Extent(5, 5, 5);
        Origin origin = new Origin(0, 0, 0);
        // int numSamplesPerDim = 10;
        byte[] pixels = new byte[3 * 3 * 3];
        BitSet indomain = new BitSet(pixels.length);
        for (int i = 0; i < pixels.length; i++) {
            indomain.set(i);
        }
        VCImageUncompressed vcImage = new VCImageUncompressed(null, pixels, extent, 3, 3, 3);
        RegionImage regionImage = new RegionImage(vcImage, 3, extent, origin, RegionImage.NO_SMOOTHING);
        CartesianMesh mesh = CartesianMesh.createSimpleCartesianMesh(origin, extent, new ISize(regionImage.getNumX(), regionImage.getNumY(), regionImage.getNumZ()), regionImage, true);
        FunctionStatistics results = FunctionRangeGenerator.getFunctionStatistics(exp, varStats, times, mesh, indomain, VariableType.VOLUME);
        System.out.println(results.getDefaultDatasetRange().toString());
    } catch (Exception e) {
        e.printStackTrace();
    }
}