Beispiel #1
0
        public void ApplyWindowLeveling( )
        {
            try
            {
                if (image != null && image.IsGray)
                {
                    if (image.MaxValue == 0)
                    {
                        MinMaxValuesCommand cmd = new MinMaxValuesCommand();
                        cmd.Run(image);
                        image.MinValue = cmd.MinimumValue;
                        image.MaxValue = cmd.MaximumValue;
                    }

                    MinMaxValuesCommand minMaxCommand = new MinMaxValuesCommand();

                    minMaxCommand.Run(image);
                    image.MinValue = minMaxCommand.MinimumValue;
                    image.MaxValue = minMaxCommand.MaximumValue;
                    ApplyLinearVoiLookupTableCommand voiCommand = new ApplyLinearVoiLookupTableCommand();
                    if (ReverseOrder)
                    {
                        voiCommand.Flags = VoiLookupTableCommandFlags.ReverseOrder;
                    }
                    else
                    {
                        voiCommand.Flags = VoiLookupTableCommandFlags.None;
                    }

                    voiCommand.Center = _WindowCenter;
                    voiCommand.Width  = _WindowWidth;
                    voiCommand.Run(image);
                }
            }
            catch
            {
            }
        }
Beispiel #2
0
        private void ApplyFilter()
        {
            try
            {
                RasterImage runImage = _originalBitmap.Clone();

                if (_cbInvert.Checked)
                {
                    runImage.UseLookupTable = false;
                    InvertCommand invComd = new InvertCommand();
                    invComd.Run(runImage);
                }

                BackGroundRemovalCommand backgroundRemovalCommand = new BackGroundRemovalCommand(Convert.ToInt32(_numRemovalFactor.Value));
                backgroundRemovalCommand.Run(runImage);

                MinMaxValuesCommand minMaxCmd = new MinMaxValuesCommand();
                minMaxCmd.Run(runImage);
                int min = minMaxCmd.MinimumValue;
                int max = minMaxCmd.MaximumValue;

                if (_cbEnableEnhancements.Checked)
                {
                    AverageCommand avrcmd = new AverageCommand();
                    avrcmd.Dimension = 5;
                    avrcmd.Run(runImage);

                    MultiscaleEnhancementCommand MSECommand = new MultiscaleEnhancementCommand();
                    MSECommand.Contrast            = Convert.ToInt32(_numContrast.Value * 100);
                    MSECommand.EdgeCoefficient     = Convert.ToInt32(_numEdgeCoef.Value * 100);
                    MSECommand.EdgeLevels          = Convert.ToInt32(_numEdgeLevel.Value);
                    MSECommand.LatitudeCoefficient = 140;
                    MSECommand.LatitudeLevels      = 5;
                    MSECommand.Flags = MultiscaleEnhancementCommandFlags.EdgeEnhancement | MultiscaleEnhancementCommandFlags.LatitudeReduction;
                    MSECommand.Type  = MultiscaleEnhancementCommandType.Gaussian;
                    MSECommand.Run(runImage);
                }
                else
                {
                    AverageCommand avrcmd = new AverageCommand();
                    avrcmd.Dimension = 3;
                    avrcmd.Run(runImage);
                }

                ApplyLinearVoiLookupTableCommand voiCmd = new ApplyLinearVoiLookupTableCommand();
                voiCmd.Center = (min + max) / 2;
                voiCmd.Width  = max - min;
                voiCmd.Flags  = VoiLookupTableCommandFlags.UpdateMinMax;
                voiCmd.Run(runImage);

                GetLinearVoiLookupTableCommand voiLutCommand = new GetLinearVoiLookupTableCommand(GetLinearVoiLookupTableCommandFlags.None);
                voiLutCommand.Run(runImage);
                _form.WindowLevelWidth  = (int)voiLutCommand.Width;
                _form.WindowLevelCenter = (int)voiLutCommand.Center;

                _viewer.Image = runImage;
            }
            catch (System.Exception /*ex*/)
            {
            }
        }
Beispiel #3
0
        private void AutoApplyWW_WC(MedicalViewerCell cell, int _WW, int _WC)
        {

            try
            {
                if (cell.Image.Order == RasterByteOrder.Gray && cell.Image.BitsPerPixel > 8)
                {
                    // update lookup table

                    try
                    {

                        ApplyLinearVoiLookupTableCommand command = new ApplyLinearVoiLookupTableCommand();
                        MinMaxBitsCommand minMaxBits = new MinMaxBitsCommand();
                        MinMaxValuesCommand minMaxValues = new MinMaxValuesCommand();
                        //if (ADJUST_WOB)
                        //command.Flags = VoiLookupTableCommandFlags.ReverseOrder;
                        // else
                        command.Flags = VoiLookupTableCommandFlags.None;

                        minMaxBits.Run(cell.Image);
                        cell.Image.LowBit = minMaxBits.MinimumBit;
                        cell.Image.HighBit = minMaxBits.MaximumBit;
                        minMaxValues.Run(cell.Image);
                        command.Width = _WW;
                        command.Center = _WC;
                        command.Run(cell.Image);
                        cell.Invalidate();
                        WindowLevelCommand _WindowLevelCommand = new WindowLevelCommand();
                        _WindowLevelCommand.HighBit = cell.Image.HighBit;
                        _WindowLevelCommand.LowBit = cell.Image.LowBit;
                        _WindowLevelCommand.LookupTable = cell.Image.GetLookupTable();
                        //_WindowLevelCommand.Order = RasterByteOrder.Rgb;
                        _WindowLevelCommand.Run(cell.Image);
                    }
                    catch
                    {
                    }
                }
            }
            catch
            {
            }
            finally
            {

            }
        }
Beispiel #4
0
        private void AutoApplyWW_WC(RasterImage img)
        {
            
            try
            {
                if (lblAppliedLastWL.IsChecked==false || WC == 0 || WW == 0)
                {
                    AllowAppliedWL = false;
                    return;
                }
                using (Leadtools.Commands.Demos.WaitCursor wait = new Leadtools.Commands.Demos.WaitCursor())
                {


                    if (img.Order == RasterByteOrder.Gray && img.BitsPerPixel > 8)
                    {
                        // update lookup table

                        try
                        {

                            ApplyLinearVoiLookupTableCommand command = new ApplyLinearVoiLookupTableCommand();
                            MinMaxBitsCommand minMaxBits = new MinMaxBitsCommand();
                            MinMaxValuesCommand minMaxValues = new MinMaxValuesCommand();
                            if (ADJUST_WOB)
                                command.Flags = VoiLookupTableCommandFlags.ReverseOrder;
                            else
                                command.Flags = VoiLookupTableCommandFlags.None;

                            minMaxBits.Run(img);
                            img.LowBit = minMaxBits.MinimumBit;
                            img.HighBit = minMaxBits.MaximumBit;
                            minMaxValues.Run(img);
                            command.Width = WW;
                            command.Center = WC;
                            command.Run(img);
                            //_CurrCell.Invalidate();
                        }
                        catch
                        {
                        }
                    }



                }
            }
            catch
            {
            }
            finally
            {
               
            }
        }
Beispiel #5
0
        private void AutoApplyWW_WC()
        {
            bool AllowAppliedWL = true;
            try
            {
                if (lblAppliedLastWL.IsChecked==false || WC == 0 || WW == 0)
                {
                    AllowAppliedWL = false;
                    return;
                }
                using (Leadtools.Commands.Demos.WaitCursor wait = new Leadtools.Commands.Demos.WaitCursor())
                {


                    if (_CurrCell.Image.Order == RasterByteOrder.Gray && _CurrCell.Image.BitsPerPixel > 8)
                    {
                        // update lookup table

                        try
                        {

                            ApplyLinearVoiLookupTableCommand command = new ApplyLinearVoiLookupTableCommand();
                            MinMaxBitsCommand minMaxBits = new MinMaxBitsCommand();
                            MinMaxValuesCommand minMaxValues = new MinMaxValuesCommand();
                            if (ADJUST_WOB)
                                command.Flags = VoiLookupTableCommandFlags.ReverseOrder;
                            else
                                command.Flags = VoiLookupTableCommandFlags.None;

                            minMaxBits.Run(_CurrCell.Image);
                            _CurrCell.Image.LowBit = minMaxBits.MinimumBit;
                            _CurrCell.Image.HighBit = minMaxBits.MaximumBit;
                            minMaxValues.Run(_CurrCell.Image);
                            command.Width = WW;
                            command.Center = WC;
                            command.Run(_CurrCell.Image);
                            _CurrCell.Invalidate();
                        }
                        catch
                        {
                        }
                    }
                }
            }
            catch
            {
            }
            finally
            {
                if (AllowAppliedWL)
                {
                    _DicomMedicalViewer.SetWindowLevel(_CurrCell, WW, WC);
                    
                }
            }
        }