weasis窗位调节源码分析

EventManager

setAction(getMoveTroughSliceAction(20, TIME.SECOND, 0.1));

    @Override
    protected SliderCineListener getMoveTroughSliceAction(int speed, TIME time, double mouseSensivity) {
        return new SliderCineListener(ActionW.SCROLL_SERIES, 1, 2, 1, speed, time, mouseSensivity) {

            protected CineThread currentCine;

            @Override
            public void stateChanged(BoundedRangeModel model) {

                ViewCanvas<DicomImageElement> view2d = null;
                Series<DicomImageElement> series = null;
                SynchCineEvent mediaEvent = null;
                DicomImageElement image = null;
                Optional<ToggleButtonListener> defaultPresetAction =
                    getAction(ActionW.DEFAULT_PRESET, ToggleButtonListener.class);
                boolean isDefaultPresetSelected =
                    defaultPresetAction.isPresent() ? defaultPresetAction.get().isSelected() : true;

                if (selectedView2dContainer != null) {
                    view2d = selectedView2dContainer.getSelectedImagePane();
                }

                if (view2d != null && view2d.getSeries() instanceof Series) {
                    series = (Series<DicomImageElement>) view2d.getSeries();
                    if (series != null) {
                        // Model contains display value, value-1 is the index value of a sequence
                        int index = model.getValue() - 1;
                        image = series.getMedia(index,
                            (Filter<DicomImageElement>) view2d.getActionValue(ActionW.FILTERED_SERIES.cmd()),
                            view2d.getCurrentSortComparator());
                        mediaEvent = new SynchCineEvent(view2d, image, index);
                        // Ensure to load image before calling the default preset (requires pixel min and max)
                        if (image != null && !image.isImageAvailable()) {
                            image.getImage();
                        }
                    }
                }

                Optional<ComboItemListener> layoutAction = getAction(ActionW.LAYOUT, ComboItemListener.class);
                Optional<ComboItemListener> synchAction = getAction(ActionW.SYNCH, ComboItemListener.class);

                if (image != null && layoutAction.isPresent() && View2dFactory
                    .getViewTypeNumber((GridBagLayoutModel) layoutAction.get().getSelectedItem(), ViewCanvas.class) > 1
                    && synchAction.isPresent()) {

                    SynchView synchview = (SynchView) synchAction.get().getSelectedItem();
                    if (synchview.getSynchData().isActionEnable(ActionW.SCROLL_SERIES.cmd())) {
                        double[] val = (double[]) image.getTagValue(TagW.SlicePosition);
                        if (val != null) {
                            mediaEvent.setLocation(val[0] + val[1] + val[2]);
                        }
                    } else {
                        if (selectedView2dContainer != null) {
                            final List<ViewCanvas<DicomImageElement>> panes = selectedView2dContainer.getImagePanels();
                            for (ViewCanvas<DicomImageElement> p : panes) {
                                Boolean cutlines = (Boolean) p.getActionValue(ActionW.SYNCH_CROSSLINE.cmd());
                                if (cutlines != null && cutlines) {
                                    double[] val = (double[]) image.getTagValue(TagW.SlicePosition);
                                    if (val != null) {
                                        mediaEvent.setLocation(val[0] + val[1] + val[2]);
                                    } else {
                                        return; // Do not throw event
                                    }
                                    break;
                                }
                            }
                        }
                    }
                }

                Optional<SliderChangeListener> windowAction = getAction(ActionW.WINDOW, SliderChangeListener.class);
                Optional<SliderChangeListener> levelAction = getAction(ActionW.LEVEL, SliderChangeListener.class);
                if (view2d != null && image != view2d.getImage() && image != null && windowAction.isPresent()
                    && levelAction.isPresent()) {
                    Optional<ComboItemListener> presetAction = getAction(ActionW.PRESET, ComboItemListener.class);
                    PresetWindowLevel oldPreset =
                        presetAction.isPresent() ? (PresetWindowLevel) presetAction.get().getSelectedItem() : null;
                    PresetWindowLevel newPreset = null;
                    boolean pixelPadding = JMVUtils.getNULLtoTrue(
                        view2d.getDisplayOpManager().getParamValue(WindowOp.OP_NAME, ActionW.IMAGE_PIX_PADDING.cmd()));

                    List<PresetWindowLevel> newPresetList = image.getPresetList(pixelPadding);

                    // Assume the image cannot display when win =1 and level = 0
                    if (oldPreset != null
                        || (windowAction.get().getSliderValue() <= 1 && levelAction.get().getSliderValue() == 0)) {
                        if (isDefaultPresetSelected) {
                            newPreset = image.getDefaultPreset(pixelPadding);
                        } else {
                            if (oldPreset != null) {
                                for (PresetWindowLevel preset : newPresetList) {
                                    if (preset.getName().equals(oldPreset.getName())) {
                                        newPreset = preset;
                                        break;
                                    }
                                }
                            }
                            // set default preset when the old preset is not available any more
                            if (newPreset == null) {
                                newPreset = image.getDefaultPreset(pixelPadding);
                                isDefaultPresetSelected = true;
                            }
                        }
                    }

                    Optional<ComboItemListener> lutShapeAction = getAction(ActionW.LUT_SHAPE, ComboItemListener.class);
                    Double windowValue = newPreset == null ? windowAction.get().getRealValue() : newPreset.getWindow();
                    Double levelValue = newPreset == null ? levelAction.get().getRealValue() : newPreset.getLevel();
                    LutShape lutShapeItem = newPreset == null
                        ? lutShapeAction.isPresent() ? (LutShape) lutShapeAction.get().getSelectedItem() : null
                        : newPreset.getLutShape();

                    Double levelMin =
                        (Double) view2d.getDisplayOpManager().getParamValue(WindowOp.OP_NAME, ActionW.LEVEL_MIN.cmd());
                    Double levelMax =
                        (Double) view2d.getDisplayOpManager().getParamValue(WindowOp.OP_NAME, ActionW.LEVEL_MAX.cmd());

                    PresentationStateReader prReader =
                        (PresentationStateReader) view2d.getActionValue(PresentationStateReader.TAG_PR_READER);
                    if (levelMin == null || levelMax == null) {
                        levelMin = Math.min(levelValue - windowValue / 2.0, image.getMinValue(prReader, pixelPadding));
                        levelMax = Math.max(levelValue + windowValue / 2.0, image.getMaxValue(prReader, pixelPadding));
                    } else {
                        levelMin = Math.min(levelMin, image.getMinValue(prReader, pixelPadding));
                        levelMax = Math.max(levelMax, image.getMaxValue(prReader, pixelPadding));
                    }

                    // FIX : setting actionInView here without firing a propertyChange avoid another call to
                    // imageLayer.updateImageOperation(WindowOp.name.....
                    // TODO pass to mediaEvent with PR and KO

                    ImageOpNode node = view2d.getDisplayOpManager().getNode(WindowOp.OP_NAME);
                    if (node != null) {
                        node.setParam(ActionW.PRESET.cmd(), newPreset);
                        node.setParam(ActionW.DEFAULT_PRESET.cmd(), isDefaultPresetSelected);
                        node.setParam(ActionW.WINDOW.cmd(), windowValue);
                        node.setParam(ActionW.LEVEL.cmd(), levelValue);
                        node.setParam(ActionW.LEVEL_MIN.cmd(), levelMin);
                        node.setParam(ActionW.LEVEL_MAX.cmd(), levelMax);
                        node.setParam(ActionW.LUT_SHAPE.cmd(), lutShapeItem);
                    }
                    updateWindowLevelComponentsListener(image, view2d);

                }

                firePropertyChange(ActionW.SYNCH.cmd(), null, mediaEvent);
                if (image != null) {
                    fireSeriesViewerListeners(
                        new SeriesViewerEvent(selectedView2dContainer, series, image, EVENT.SELECT));
                }

                updateKeyObjectComponentsListener(view2d);

            }

View2d

 public void propertyChange(PropertyChangeEvent evt) {
        super.propertyChange(evt);
        if (series == null) {
            return;
        }

        RenderedImage dispImage = imageLayer.getDisplayImage();
        OpManager disOp = imageLayer.getDisplayOpManager();
        final String name = evt.getPropertyName();
        if (name.equals(ActionW.SYNCH.cmd())) {
            SynchEvent synch = (SynchEvent) evt.getNewValue();
            SynchData synchData = (SynchData) actionsInView.get(ActionW.SYNCH_LINK.cmd());
            boolean tile = synchData != null && SynchData.Mode.TILE.equals(synchData.getMode());
            if (synchData != null && Mode.NONE.equals(synchData.getMode())) {
                return;
            }
            for (Entry<String, Object> entry : synch.getEvents().entrySet()) {
                final String command = entry.getKey();
                final Object val = entry.getValue();
                if (synchData != null && !synchData.isActionEnable(command)) {
                    continue;
                }

                if (command.equals(ActionW.PRESET.cmd())) {
                    actionsInView.put(ActionW.PRESET.cmd(), val);

                    if (val instanceof PresetWindowLevel) {
                        PresetWindowLevel preset = (PresetWindowLevel) val;
                        DicomImageElement img = getImage();
                        ImageOpNode node = disOp.getNode(WindowOp.OP_NAME);

                        if (node != null) {
                            node.setParam(ActionW.WINDOW.cmd(), preset.getWindow());
                            node.setParam(ActionW.LEVEL.cmd(), preset.getLevel());
                            node.setParam(ActionW.LUT_SHAPE.cmd(), preset.getLutShape());
                            // When series synchronization, do not synch preset from other series
                            if (img == null || !img.containsPreset(preset)) {
                                List<PresetWindowLevel> presets =
                                    (List<PresetWindowLevel>) actionsInView.get(PRManager.PR_PRESETS);
                                if (presets == null || !presets.contains(preset)) {
                                    preset = null;
                                }
                            }
                            node.setParam(ActionW.PRESET.cmd(), preset);
                        }
                        imageLayer.updateDisplayOperations();
                    }
                }

RenderedImageLayer

    @Override
    public synchronized void setEnableDispOperations(boolean enabled) {
        this.enableDispOperations = enabled;
        if (enabled) {
            updateDisplayOperations();
        }
    }

    @Override
    public void updateDisplayOperations() {
        if (isEnableDispOperations()) {
            displayImage = disOpManager.process();
            fireImageChanged();
        }
    }

    public void fireImageChanged() {
        if (displayImage == null) {
            disOpManager.clearNodeIOCache();
        }
        PlanarImage img = null;
        if (buildIterator && sourceImage != null) {
            img = sourceImage.getImage(preprocessing);
        }
        readIterator = (img == null) ? null : RandomIterFactory.create(img, null);
        fireLayerChanged();
    }

    public void fireLayerChanged() {
        for (int i = 0; i < listenerList.size(); i++) {
            listenerList.get(i).handleLayerChanged(this);
        }
    }

View2d

    @Override
    public void handleLayerChanged(ImageLayer layer) {
        repaint();
    }