public static async Task ReplaceColorAsync(this IColorMatrix sourceColorMatrix, ColorItem oldColorItem, Color newColor, bool convertToBackground = false)
        {
            Color oldColor = oldColorItem;

            for (uint row = 0; row < sourceColorMatrix.Height; row++)
            {
                for (uint column = 0; column < sourceColorMatrix.Width; column++)
                {
                    if (sourceColorMatrix.ColorItems[row, column] == oldColor &&
                        sourceColorMatrix.ColorItems[row, column].ItemType == oldColorItem.ItemType)
                    {
                        ColorItem newItem = new ColorItem()
                        {
                            A        = newColor.A,
                            R        = newColor.R,
                            G        = newColor.G,
                            B        = newColor.B,
                            ItemType = convertToBackground ? ColorItem.ColorItemType.Background : sourceColorMatrix.ColorItems[row, column].ItemType
                        };

                        await sourceColorMatrix.SetItem(row, column, newItem);
                    }
                }
            }
        }
Beispiel #2
0
 public static async Task Clear(this IColorMatrix sourceColorMatrix, Color color)
 {
     for (uint row = 0; row < sourceColorMatrix.Height; row++)
     {
         for (uint column = 0; column < sourceColorMatrix.Width; column++)
         {
             await sourceColorMatrix.SetItem(row, column, ColorItem.FromColor(color, ColorItem.ColorItemType.Background));
         }
     }
 }
Beispiel #3
0
 public static async Task CopyTo(this IColorMatrix sourceColorMatrix, IColorMatrix targetColorMatrix)
 {
     for (uint row = 0; row < sourceColorMatrix.Height; row++)
     {
         for (uint column = 0; column < sourceColorMatrix.Width; column++)
         {
             await targetColorMatrix.SetItem(row, column, sourceColorMatrix.ColorItems[row, column]);
         }
     }
 }
        public static async Task FlipHorizontalAsync(this IColorMatrix sourceColorMatrix)
        {
            IColorMatrix me = await sourceColorMatrix.CloneAsync();

            for (uint row = 0; row < sourceColorMatrix.Height; row++)
            {
                for (uint column = 0; column < sourceColorMatrix.Width; column++)
                {
                    await sourceColorMatrix.SetItem(row, column, me.ColorItems[row, (sourceColorMatrix.Width - 1) - column]);
                }
            }
        }
        public static async Task RotateClockwiseAsync(this IColorMatrix sourceColorMatrix)
        {
            IColorMatrix me = await sourceColorMatrix.CloneAsync();

            for (uint row = 0; row < sourceColorMatrix.Height; row++)
            {
                for (uint column = 0; column < sourceColorMatrix.Width; column++)
                {
                    await sourceColorMatrix.SetItem(row, column, me.ColorItems[(sourceColorMatrix.Height - 1) - column, row]);
                }
            }
        }
Beispiel #6
0
        public static Task <IColorMatrix> CloneAsync(this IColorMatrix sourceColorMatrix)
        {
            IColorMatrix returnValue = new ColorMatrix(sourceColorMatrix.Width, sourceColorMatrix.Height);

            for (uint row = 0; row < sourceColorMatrix.Height; row++)
            {
                for (uint column = 0; column < sourceColorMatrix.Width; column++)
                {
                    returnValue.ColorItems[column, row] = sourceColorMatrix.ColorItems[column, row];
                }
            }

            return(Task.FromResult(returnValue));
        }
Beispiel #7
0
        public static uint GetPixelCount(this IColorMatrix colorMatrix, ColorItem.ColorItemType itemType)
        {
            uint returnValue = 0;

            for (uint row = 0; row < colorMatrix.Height; row++)
            {
                for (uint column = 0; column < colorMatrix.Width; column++)
                {
                    if (colorMatrix.ColorItems[row, column].ItemType == itemType)
                    {
                        returnValue++;
                    }
                }
            }

            return(returnValue);
        }
Beispiel #8
0
        public static Task <IList <ColorItem> > GetPaletteAsync(this IColorMatrix sourceColorMatrix)
        {
            IList <ColorItem> colors = new List <ColorItem>();

            for (int row = 0; row < sourceColorMatrix.Height; row++)
            {
                for (int column = 0; column < sourceColorMatrix.Width; column++)
                {
                    ColorItem color = sourceColorMatrix.ColorItems[row, column];

                    if (!colors.Contains(color))
                    {
                        colors.Add(color);
                    }
                }
            }

            return(Task.FromResult(colors));
        }
        /// <summary>
        /// Convert the ColorMatrix to a BGRA array.
        /// </summary>
        /// <returns>Image data in BGRA pixel format.</returns>
        public static Task <byte[]> CreateImageDataAsync(this IColorMatrix sourceColorMatrix)
        {
            byte[] returnValue = new byte[sourceColorMatrix.Width * sourceColorMatrix.Height * 4];
            int    index       = 0;

            for (int row = 0; row < sourceColorMatrix.Height; row++)
            {
                for (int column = 0; column < sourceColorMatrix.Width; column++)
                {
                    Color color = sourceColorMatrix.ColorItems[row, column];

                    // ***
                    // *** Remove background and sand pixels.
                    // ***
                    if (sourceColorMatrix.ColorItems[row, column].ItemType == ColorItem.ColorItemType.Background)
                    {
                        // ***
                        // *** Clear the color for transparent pixels.
                        // ***
                        color.A = 0;
                        color.R = 0;
                        color.G = 0;
                        color.B = 0;
                    }
                    else if (sourceColorMatrix.ColorItems[row, column].ItemType == ColorItem.ColorItemType.Sand)
                    {
                        // ***
                        // *** Leave the and color in place
                        // ***
                        color.A = 0;
                    }

                    returnValue[index + 0] = color.B;
                    returnValue[index + 1] = color.G;
                    returnValue[index + 2] = color.R;
                    returnValue[index + 3] = color.A;

                    index += 4;
                }
            }

            return(Task.FromResult(returnValue));
        }
        public static async Task ReplacePixelTypeColorAsync(this IColorMatrix sourceColorMatrix, ColorItem.ColorItemType itemType, Color newColor)
        {
            for (uint row = 0; row < sourceColorMatrix.Height; row++)
            {
                for (uint column = 0; column < sourceColorMatrix.Width; column++)
                {
                    if (sourceColorMatrix.ColorItems[row, column].ItemType == itemType)
                    {
                        ColorItem newItem = new ColorItem()
                        {
                            A = newColor.A,
                            R = newColor.R,
                            G = newColor.G,
                            B = newColor.B
                        };

                        await sourceColorMatrix.SetItem(row, column, newItem);
                    }
                }
            }
        }
Beispiel #11
0
        public async void OnClearCommand()
        {
            try
            {
                // ***
                // *** Get a copy of the current color matrix.
                // ***
                IColorMatrix oldColorMatrix = await this.ColorMatrix.CloneAsync();

                // ***
                // *** Clear the matrix.
                // ***
                await this.ColorMatrix.Clear(this.BackgroundColor);

                // ***
                // *** Clear the project name.
                // ***
                string projectName = this.ProjectName;
                this.ProjectName = String.Empty;

                // ***
                // *** Set up the undo task.
                // ***
                async Task undoAction()
                {
                    await this.ColorMatrix.CopyFrom(oldColorMatrix); this.ProjectName = projectName;
                }
                async Task redoAction()
                {
                    await this.ColorMatrix.Clear(this.BackgroundColor); this.ProjectName = String.Empty;
                }
                await this.UndoService.AddUndoTask(undoAction, redoAction, "Clear");
            }
            catch (Exception ex)
            {
                MessageDialog dialog = new MessageDialog(ex.Message, "Exception".GetLocalized());
                await dialog.ShowAsync();
            }
        }
Beispiel #12
0
        public async void OnLoadCommand()
        {
            try
            {
                FileOpenPicker openPicker = new FileOpenPicker
                {
                    ViewMode = PickerViewMode.Thumbnail,
                    SuggestedStartLocation = PickerLocationId.PicturesLibrary
                };

                openPicker.FileTypeFilter.Add(".jpg");
                openPicker.FileTypeFilter.Add(".jpeg");
                openPicker.FileTypeFilter.Add(".png");
                openPicker.FileTypeFilter.Add(".bmp");
                openPicker.FileTypeFilter.Add(".tif");
                openPicker.FileTypeFilter.Add(".tiff");

                StorageFile file = await openPicker.PickSingleFileAsync();

                if (file != null)
                {
                    // ***
                    // *** Get a copy of the current color matrix.
                    // ***
                    IColorMatrix oldColorMatrix = await this.ColorMatrix.CloneAsync();

                    IMatrixProject oldProject = this.CurrentProject;

                    // ***
                    // *** Read the image/project from an image file.
                    // ***
                    IMatrixProject project = await file.LoadFromImageAsync(ImageEditorViewModel.DefaultColumnCount, ImageEditorViewModel.DefaultColumnCount);

                    await this.ColorMatrix.CopyFrom(project.ColorMatrix);

                    await this.ApplyProjectSettings(project);

                    // ***
                    // *** Set up the undo task.
                    // ***
                    async Task undoAction()
                    {
                        await this.ColorMatrix.CopyFrom(oldColorMatrix); await this.ApplyProjectSettings(oldProject);
                    }
                    async Task redoAction()
                    {
                        await this.ColorMatrix.CopyFrom(project.ColorMatrix); await this.ApplyProjectSettings(project);
                    }
                    await this.UndoService.AddUndoTask(undoAction, redoAction, $"Load File [{file.Name}]");
                }
            }
            catch (BadImageFormatException)
            {
                MessageDialog dialog = new MessageDialog("ExceptionImageTooLarge".GetLocalized(), "Exception".GetLocalized());
                await dialog.ShowAsync();
            }
            catch (Exception ex)
            {
                MessageDialog dialog = new MessageDialog(ex.Message, "Exception".GetLocalized());
                await dialog.ShowAsync();
            }
        }
Beispiel #13
0
        private async void PixelMatrix_PixelSelected(object sender, PixelSelectedEventArgs e)
        {
            // ***
            // *** Get the current mode.
            // ***
            DrawMode mode = await this.GetDrawMode(e.KeyModifiers);

            // ***
            // *** Cache the old color of this pixel.
            // ***
            ColorItem selectedItem = await this.ColorMatrix.GetItem(e.Row, e.Column);

            switch (mode)
            {
            case DrawMode.PickColor:
            {
                ColorItem colorItem = await this.ColorMatrix.GetItem(e.Row, e.Column);

                this.PixelColor         = colorItem;
                this.PickColorIsChecked = false;

                if (_sandWasChecked)
                {
                    this.SandIsChecked = true;
                }
                else
                {
                    this.DrawIsChecked = true;
                }
            }
            break;

            case DrawMode.Draw:
            {
                if (selectedItem != this.PixelColor || selectedItem.ItemType != ColorItem.ColorItemType.Pixel)
                {
                    // ***
                    // *** Update the pixel.
                    // ***
                    Color color = this.PixelColor;
                    await this.ColorMatrix.SetItem(e.Row, e.Column, color, ColorItem.ColorItemType.Pixel);

                    // ***
                    // *** Set up the undo task.
                    // ***
                    async Task undoAction()
                    {
                        await this.ColorMatrix.SetItem(e.Row, e.Column, selectedItem);
                    }

                    async Task redoAction()
                    {
                        await this.ColorMatrix.SetItem(e.Row, e.Column, color, ColorItem.ColorItemType.Pixel);
                    }

                    await this.UndoService.AddUndoTask(undoAction, redoAction, $"Set Pixel [{e.Column}, {e.Row}, {this.PixelColor.ToString()}]");
                }
            }
            break;

            case DrawMode.Erase:
            {
                if (selectedItem != this.BackgroundColor || selectedItem.ItemType != ColorItem.ColorItemType.Background)
                {
                    // ***
                    // *** Update the pixel.
                    // ***
                    await this.ColorMatrix.SetItem(e.Row, e.Column, this.BackgroundColor, ColorItem.ColorItemType.Background);

                    // ***
                    // *** Set up the undo task.
                    // ***
                    async Task undoAction()
                    {
                        await this.ColorMatrix.SetItem(e.Row, e.Column, selectedItem);
                    }

                    async Task redoAction()
                    {
                        await this.ColorMatrix.SetItem(e.Row, e.Column, this.BackgroundColor, ColorItem.ColorItemType.Background);
                    }

                    await this.UndoService.AddUndoTask(undoAction, redoAction, $"Clear Pixel [{e.Column}, {e.Row}]");
                }
            }
            break;

            case DrawMode.EraseColor:
            {
                if (selectedItem.ItemType != ColorItem.ColorItemType.Background)
                {
                    // ***
                    // *** Clone the current matrix for the undo.
                    // ***
                    IColorMatrix oldColorMatrix = await this.ColorMatrix.CloneAsync();

                    await this.ColorMatrix.ReplaceColorAsync(selectedItem, this.BackgroundColor, true);

                    // ***
                    // *** Set up the undo task.
                    // ***
                    async Task undoAction()
                    {
                        await this.ColorMatrix.CopyFrom(oldColorMatrix);
                    }

                    async Task redoAction()
                    {
                        await this.ColorMatrix.ReplaceColorAsync(selectedItem, this.BackgroundColor, true);
                    }

                    await this.UndoService.AddUndoTask(undoAction, redoAction, $"Clear Pixels [{e.Column}, {e.Row}]");
                }
            }
            break;

            case DrawMode.Sand:
            {
                if (selectedItem != this.PixelColor || selectedItem.ItemType != ColorItem.ColorItemType.Sand)
                {
                    // ***
                    // *** Update the pixel.
                    // ***
                    Color color = this.PixelColor;
                    color.A = 255;
                    await this.ColorMatrix.SetItem(e.Row, e.Column, color, ColorItem.ColorItemType.Sand);

                    // ***
                    // *** Set up the undo task.
                    // ***
                    async Task undoAction()
                    {
                        await this.ColorMatrix.SetItem(e.Row, e.Column, selectedItem);
                    }

                    async Task redoAction()
                    {
                        await this.ColorMatrix.SetItem(e.Row, e.Column, color, ColorItem.ColorItemType.Sand);
                    }

                    await this.UndoService.AddUndoTask(undoAction, redoAction, $"Set Sand Pixel [{e.Column}, {e.Row}, {this.PixelColor.ToString()}]");
                }
            }
            break;
            }
        }