ChannelsTool.cs

Go to the documentation of this file.

using AForge;
using System.ComponentModel;
namespace BioCore
{
    public partial class ChannelsTool : Form
    {
        private HistogramControl hist = null;
        private bool initializing;
        private int histogramRequestVersion;
        private BioImage histogramLoadingImage;
        private Task histogramLoadingTask;
        private BioImage histogramImage;
        private ZCT histogramCoordinate;
        private ZCT histogramLoadingCoordinate;
        /* A property that returns a list of channels. */
        public List<Channel> Channels
        {
            get
            {
                return App.Channels;
            }
        }
        /* A property that returns the selected channel from the channelsBox. */
        public Channel SelectedChannel
        {
            get
            {
                if (channelsBox.SelectedIndex != -1)
                    return Channels[channelsBox.SelectedIndex];
                else
                    return Channels[0];
            }
        }
        /* A property that is used to get and set the value of the sampleBox.Value. */
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int SelectedSample
        {
            get
            {
                return (int)sampleBox.Value;
            }
            set
            {
                sampleBox.Value = (decimal)value;
            }
        }
        public void UpdateItems()
        {
            int selectedIndex = channelsBox.SelectedIndex;
            initializing = true;
            channelsBox.Items.Clear();
            foreach (Channel item in Channels)
            {
                channelsBox.Items.Add(item);
            }
            channelsBox.SelectedIndex = Channels.Count == 0
                ? -1
                : Math.Clamp(selectedIndex, 0, Channels.Count - 1);
            initializing = false;
        }
        /* Creating a new instance of the ChannelsTool class. */
        public ChannelsTool(List<Channel> Channels)
        {
            initializing = true;
            InitializeComponent();
            foreach (Channel item in Channels)
            {
                channelsBox.Items.Add(item);
            }
            MouseWheel += new System.Windows.Forms.MouseEventHandler(ChannelsTool_MouseWheel);
 
            if (Channels.Count == 0)
            {
                channelsBox.Enabled = false;
                sampleBox.Enabled = false;
                statsPanel.Controls.Add(new Label
                {
                    Dock = DockStyle.Fill,
                    Text = "No channel metadata is available for this image.",
                    TextAlign = ContentAlignment.MiddleCenter
                });
                initializing = false;
                return;
            }
 
            channelsBox.SelectedIndex = 0;
            Channel channel = Channels[0];
            int sample = channel.range?.Length > 0 ? 0 : -1;
            int defaultMax = channel.BitsPerPixel <= 8 ? byte.MaxValue : ushort.MaxValue;
            int minimum = sample >= 0 ? channel.range[sample].Min : 0;
            int maximum = sample >= 0 ? channel.range[sample].Max : defaultMax;
            if (channel.stats?.Length > 0)
            {
                minimum = (int)channel.stats[0].StackMin;
                maximum = (int)channel.stats[0].StackMax;
            }
            minBox.Value = Math.Clamp(minimum, (int)minBox.Minimum, (int)minBox.Maximum);
            maxBox.Value = Math.Clamp(maximum, (int)maxBox.Minimum, (int)maxBox.Maximum);
            hist = new HistogramControl(channel);
            hist.GraphMax = Math.Max(1, (int)maxBox.Value);
            maxGraphBox.Value = Math.Clamp(maxBox.Value, maxGraphBox.Minimum, maxGraphBox.Maximum);
            statsPanel.Controls.Add(hist);
            initializing = false;
            Shown += async (_, _) => await EnsureHistogramAsync();
        }
 
        private void minBox_ValueChanged(object sender, EventArgs e)
        {
            if (initializing || channelsBox.SelectedIndex == -1)
                return;
            if (hist != null)
            {
                hist.UpdateChannel(Channels[channelsBox.SelectedIndex]);
                hist.Invalidate();
                hist.Min = (int)minBox.Value;
            }
            App.Channels[channelsBox.SelectedIndex].range[(int)sampleBox.Value].Max = (int)maxBox.Value;
            App.viewer.UpdateImage();
            App.viewer.UpdateView();
        }
        private void maxBox_ValueChanged(object sender, EventArgs e)
        {
            if (initializing || channelsBox.SelectedIndex == -1)
                return;
            if (hist != null)
            {
                hist.UpdateChannel(Channels[channelsBox.SelectedIndex]);
                hist.Invalidate();
                hist.Max = (int)maxBox.Value;
            }
            App.Channels[channelsBox.SelectedIndex].range[(int)sampleBox.Value].Min = (int)minBox.Value;
            App.viewer.UpdateImage();
            App.viewer.UpdateView();
        }
        private void channelsBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (initializing || channelsBox.SelectedIndex == -1)
                return;
            Channel channel = Channels[channelsBox.SelectedIndex];
            if (channel.range == null || channel.range.Length == 0)
                return;
            sampleBox.Value = 0;
            sampleBox.Maximum = channel.range.Length - 1;
            if (minBox.Maximum < Channels[channelsBox.SelectedIndex].range[(int)sampleBox.Value].Min || maxBox.Maximum < Channels[channelsBox.SelectedIndex].range[(int)sampleBox.Value].Max)
            {
                minBox.Value = 0;
                maxBox.Value = ushort.MaxValue;
            }
            else
            {
                minBox.Value = Channels[channelsBox.SelectedIndex].range[(int)sampleBox.Value].Min;
                maxBox.Value = Channels[channelsBox.SelectedIndex].range[(int)sampleBox.Value].Max;
            }
            if (hist != null)
            {
                //hist.Statistics = Channels[channelsBox.SelectedIndex].statistics;
                hist.UpdateChannel(SelectedChannel);
                hist.Invalidate();
            }
            fluorBox.Text = SelectedChannel.Fluor;
            emisBox.Value = (decimal)SelectedChannel.Emission;
            excBox.Value = (decimal)SelectedChannel.Excitation;
            App.viewer.UpdateView();
        }
 
        private void maxUintBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            int i = int.Parse((string)maxUintBox.SelectedItem, System.Globalization.CultureInfo.InvariantCulture);
            if (i <= maxBox.Maximum)
                maxBox.Value = i;
 
        }
 
        private void ChannelsTool_FormClosing(object sender, FormClosingEventArgs e)
        {
            e.Cancel = true;
            this.Hide();
        }
 
        private void setMaxAllBut_Click(object sender, EventArgs e)
        {
            foreach (Channel c in Channels)
            {
                for (int i = 0; i < c.range.Length; i++)
                {
                    c.range[i].Max = (int)maxBox.Value;
                }
            }
            App.viewer.UpdateView();
        }
 
        private void setMinAllBut_Click(object sender, EventArgs e)
        {
            foreach (Channel c in Channels)
            {
                for (int i = 0; i < c.range.Length; i++)
                {
                    c.range[i].Min = (int)minBox.Value;
                }
            }
            App.viewer.UpdateView();
        }
 
        private void ChannelsTool_Activated(object sender, EventArgs e)
        {
            UpdateItems();
            if (Channels.Count == 0 || channelsBox.SelectedIndex < 0 || hist == null)
                return;
            Channel channel = SelectedChannel;
            if (channel.range == null || channel.range.Length == 0)
                return;
            initializing = true;
            sampleBox.Maximum = channel.range.Length - 1;
            sampleBox.Value = Math.Min(sampleBox.Value, sampleBox.Maximum);
            minBox.Value = Math.Clamp(channel.range[(int)sampleBox.Value].Min,
                (int)minBox.Minimum, (int)minBox.Maximum);
            maxBox.Value = Math.Clamp(channel.range[(int)sampleBox.Value].Max,
                (int)maxBox.Minimum, (int)maxBox.Maximum);
            initializing = false;
            hist.UpdateChannel(channel);
            hist.UpdateView();
            _ = EnsureHistogramAsync();
 
        }
 
        private async Task EnsureHistogramAsync()
        {
            BioImage image = ImageView.SelectedImage;
            if (image == null || hist == null)
                return;
 
            ZCT coordinate = image.Coordinate;
            int requestVersion = ++histogramRequestVersion;
            if (ReferenceEquals(histogramImage, image) && SameCoordinate(histogramCoordinate, coordinate) &&
                ZarrChannelView.HasHistogramStatistics(image))
            {
                hist.StatusMessage = "";
                ApplyFrameRange();
                hist.Invalidate();
                return;
            }
 
            hist.StatusMessage = "Loading histogram…";
            hist.Invalidate();
            try
            {
                if (!ReferenceEquals(histogramLoadingImage, image) ||
                    !SameCoordinate(histogramLoadingCoordinate, coordinate) ||
                    histogramLoadingTask == null || histogramLoadingTask.IsCompleted)
                {
                    histogramLoadingImage = image;
                    histogramLoadingCoordinate = coordinate;
                    histogramLoadingTask = ZarrChannelView.EnsureHistogramStatisticsAsync(
                        image, coordinate);
                }
                await histogramLoadingTask;
                if (requestVersion != histogramRequestVersion || image != ImageView.SelectedImage)
                    return;
                histogramImage = image;
                histogramCoordinate = coordinate;
                hist.StatusMessage = ZarrChannelView.HasHistogramStatistics(image)
                    ? ""
                    : "Histogram data is unavailable for this image.";
                hist.UpdateChannel(SelectedChannel);
                ApplyFrameRange();
                hist.Invalidate();
            }
            catch (Exception ex)
            {
                if (requestVersion != histogramRequestVersion)
                    return;
                hist.StatusMessage = $"Could not load histogram: {ex.Message}";
                hist.Invalidate();
            }
        }
 
        public void RefreshHistogram()
        {
            if (Visible)
                _ = EnsureHistogramAsync();
        }
 
        private void ApplyFrameRange()
        {
            if (channelsBox.SelectedIndex < 0 || SelectedChannel.stats == null ||
                SelectedChannel.stats.Length == 0)
                return;
 
            int sample = Math.Clamp((int)sampleBox.Value, 0, SelectedChannel.stats.Length - 1);
            Statistics statistics = SelectedChannel.stats[sample];
            int minimum = Math.Clamp((int)statistics.StackMin, (int)minBox.Minimum, (int)minBox.Maximum);
            int maximum = Math.Clamp((int)statistics.StackMax, minimum, (int)maxBox.Maximum);
            int graphMaximum = Math.Max(1, maximum);
            int graphMinimum = Math.Min(minimum, graphMaximum);
            int histogramBin = Math.Max(1, (graphMaximum - graphMinimum + 255) / 256);
 
            initializing = true;
            minBox.Value = minimum;
            maxBox.Value = maximum;
            minGraphBox.Value = Math.Clamp(graphMinimum,
                (int)minGraphBox.Minimum, (int)minGraphBox.Maximum);
            maxGraphBox.Value = Math.Clamp(graphMaximum,
                (int)maxGraphBox.Minimum, (int)maxGraphBox.Maximum);
            binBox.Value = Math.Clamp(histogramBin, (int)binBox.Minimum, (int)binBox.Maximum);
            initializing = false;
 
            hist.GraphMin = graphMinimum;
            hist.GraphMax = graphMaximum;
            hist.Bin = histogramBin;
        }
 
        private static bool SameCoordinate(ZCT left, ZCT right) =>
            left.Z == right.Z && left.C == right.C && left.T == right.T;
 
        private void ChannelsTool_ResizeEnd(object sender, EventArgs e)
        {
            hist?.UpdateView();
        }
 
        private void maxUintBox2_SelectedIndexChanged(object sender, EventArgs e)
        {
            int i = int.Parse((string)maxUintBox2.SelectedItem, System.Globalization.CultureInfo.InvariantCulture);
            if (i <= maxGraphBox.Maximum)
                maxGraphBox.Value = i;
            if (i == 255)
            {
                maxGraphBox.Value = 255;
                binBox.Value = 1;
            }
        }
 
        private void minGraphBox_ValueChanged(object sender, EventArgs e)
        {
            if (hist != null)
            {
                hist.GraphMin = (int)minGraphBox.Value;
                hist.Invalidate();
            }
        }
 
        private void maxGraphBox_ValueChanged(object sender, EventArgs e)
        {
            if (hist != null)
            {
                hist.GraphMax = (int)maxGraphBox.Value;
                hist.Invalidate();
            }
        }
        private void binBox_ValueChanged(object sender, EventArgs e)
        {
            if (hist != null)
            {
                hist.Bin = (int)binBox.Value;
                hist.Invalidate();
            }
        }
 
        private void ChannelsTool_MouseDown(object sender, MouseEventArgs e)
        {
 
        }
        private bool pressedX1 = false;
        private bool pressedX2 = false;
        private void ChannelsTool_MouseMove(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.XButton1)
            {
                if (channelsBox.SelectedIndex < channelsBox.Items.Count - 1)
                {
                    if (pressedX1 == false)
                    {
                        channelsBox.SelectedIndex++;
                        pressedX1 = true;
                        return;
                    }
                }
            }
            pressedX1 = false;
            if (e.Button == MouseButtons.XButton2)
            {
                if (channelsBox.SelectedIndex > 0)
                {
                    if (pressedX2 == false)
                    {
                        channelsBox.SelectedIndex--;
                        pressedX2 = true;
                        return;
                    }
                }
            }
            pressedX2 = false;
        }
 
        private void ChannelsTool_MouseWheel(object sender, MouseEventArgs e)
        {
            if (e.Delta == 0)
                return;
            int i = 100;
            if (maxGraphBox.Value < 255)
                i = 10;
            if (e.Delta > 0)
            {
                if (maxGraphBox.Value + i < maxGraphBox.Maximum)
                {
                    maxGraphBox.Value += i;
                    hist.Invalidate();
                    return;
                }
            }
            else
            if (maxGraphBox.Value - i > maxGraphBox.Minimum)
            {
                maxGraphBox.Value -= i;
                hist.Invalidate();
                return;
            }
        }
 
        private void stackHistoBox_CheckedChanged(object sender, EventArgs e)
        {
            hist.StackHistogram = stackHistoBox.Checked;
            hist.Invalidate();
        }
 
        private void setMinToolStripMenuItem_Click(object sender, EventArgs e)
        {
            minBox.Value = (int)hist.MouseValX;
        }
 
        private void setMaxToolStripMenuItem_Click(object sender, EventArgs e)
        {
            maxBox.Value = (int)hist.MouseValX;
        }
 
        private void applyBut_Click(object sender, EventArgs e)
        {
            ImageView.SelectedImage.Bake(ImageView.SelectedImage.RChannel.RangeR, ImageView.SelectedImage.GChannel.RangeG, ImageView.SelectedImage.BChannel.RangeB);
        }
 
        private void minToolStripMenuItem_Click(object sender, EventArgs e)
        {
            minBox.Value = (decimal)SelectedChannel.stats[channelsBox.SelectedIndex].StackMin;
        }
 
        private void maxToolStripMenuItem_Click(object sender, EventArgs e)
        {
            minBox.Value = (decimal)SelectedChannel.stats[channelsBox.SelectedIndex].StackMax;
        }
 
        private void medianToolStripMenuItem_Click(object sender, EventArgs e)
        {
            minBox.Value = (decimal)SelectedChannel.stats[channelsBox.SelectedIndex].StackMedian;
        }
 
        private void meanToolStripMenuItem_Click(object sender, EventArgs e)
        {
            minBox.Value = (decimal)SelectedChannel.stats[channelsBox.SelectedIndex].StackMean;
        }
 
        private void toolStripMenuItem1_Click(object sender, EventArgs e)
        {
            maxBox.Value = (decimal)SelectedChannel.stats[channelsBox.SelectedIndex].StackMin;
        }
 
        private void toolStripMenuItem2_Click(object sender, EventArgs e)
        {
            maxBox.Value = (decimal)SelectedChannel.stats[channelsBox.SelectedIndex].StackMax;
        }
        private void toolStripMenuItem3_Click(object sender, EventArgs e)
        {
            maxBox.Value = (decimal)SelectedChannel.stats[channelsBox.SelectedIndex].StackMedian;
        }
        private void toolStripMenuItem4_Click(object sender, EventArgs e)
        {
            maxBox.Value = (decimal)SelectedChannel.stats[channelsBox.SelectedIndex].StackMean;
        }
 
        private void updateBut_Click(object sender, EventArgs e)
        {
            if (ImageView.SelectedImage.bitsPerPixel > 8)
            {
                ImageView.SelectedImage.StackThreshold(true);
                if (ImageView.SelectedImage.RGBChannelCount == 1)
                {
                    maxBox.Value = (decimal)ImageView.SelectedImage.Channels[channelsBox.SelectedIndex].stats[0].StackMax;
                    minBox.Value = (decimal)ImageView.SelectedImage.Channels[channelsBox.SelectedIndex].stats[0].StackMin;
                }
                else
                {
                    maxBox.Value = (decimal)ImageView.SelectedImage.Channels[channelsBox.SelectedIndex].stats[channelsBox.SelectedIndex].StackMax;
                    minBox.Value = (decimal)ImageView.SelectedImage.Channels[channelsBox.SelectedIndex].stats[channelsBox.SelectedIndex].StackMin;
                }
            }
            else
            {
                ImageView.SelectedImage.StackThreshold(false);
            }
            App.viewer.UpdateImage();
        }
 
        private void sampleBox_ValueChanged(object sender, EventArgs e)
        {
            if (initializing || Channels.Count == 0)
                return;
            if (channelsBox.SelectedIndex == -1)
                channelsBox.SelectedIndex = 0;
            minBox.Value = Channels[channelsBox.SelectedIndex].range[(int)sampleBox.Value].Min;
            maxBox.Value = Channels[channelsBox.SelectedIndex].range[(int)sampleBox.Value].Max;
            if (hist != null)
            {
                //hist.Statistics = Channels[channelsBox.SelectedIndex].statistics;
                hist.UpdateChannel(SelectedChannel);
                hist.Invalidate();
            }
            App.viewer.UpdateView();
        }
 
        private void excBox_ValueChanged(object sender, EventArgs e)
        {
            SelectedChannel.Excitation = (int)excBox.Value;
        }
 
        private void emisBox_ValueChanged(object sender, EventArgs e)
        {
            SelectedChannel.Emission = (int)emisBox.Value;
        }
 
        private void fluorBox_TextChanged(object sender, EventArgs e)
        {
            SelectedChannel.Fluor = fluorBox.Text;
        }
    }
}