Тема- Выдача на экран изображения с эффектами Выполнил- студент группы A31 Хараян Д

Работа добавлена на сайт samzan.net:

МИНОБРНАУКИ РОССИИ

Федеральное государственное автономное образовательное

учреждение высшего профессионального образования

«ЮЖНЫЙ ФЕДЕРАЛЬНЫЙ УНИВЕРСИТЕТ»

Факультет автоматики и вычислительной техники

Кафедра вычислительной техники

Пояснительная записка

к курсовой работе

По курсу: «Компьютерная графика»

Тема: «Выдача на экран изображения с эффектами»

Выполнил:

студент группы A-31

Хараян Д. Г. _______________

(подпись)

Проверил доцент кафедры МОП ЭВМ:

Селянкин В.В. _______________

(подпись)

Дата: ___.___.2013_ г.

Таганрог 2013г.

Аннотация

Программный продукт представляет компьютерную программу, реализующую добавление одного или нескольких эффектов к изображению. С помощью программы можно выбрать необходимое изображение и применить эффект (эффекты), а после сохранить полученное изображение в одном из широко используемых графических форматов.

Приложение написано в среде Windows, язык программирования – Visual C#, приложение предназначено для использования на персональном компьютере.

Содержание

[1] Содержание

[2] Техническое задание

[3] Постановка задачи

[4] Введение

[5] Описание алгоритмов реализации эффектов для изображения

[6] Наложение телевизионных помех (имитация)

[7] Случайно разбросанные квадратики

[8] Деление изображения линиями на 4 части от центра к краям

[9] Деление изображения линиями на 4 части от краев к центру

[10] Алгоритм установки прозрачности изображения

[11] Алгоритм восстановления прозрачного изображения

[12] Алгоритм получения негатива изображения

[13] Алгоритм фильтрации изображения для ослабления перепадов яркости

[14] Алгоритм получения черно-белого изображения

[15] Описание программного продукта

[16] Программно-аппаратные требования

[17] Язык и среда программирования

[18] Входные и выходные данные

[19] Структура программы

[20] Описание структурных элементов программы

[21] Описание интерфейса и инструкция пользователю

[22] Заключение

[23] Библиографический список

[24] Приложение 1

[25] Приложение 2

Техническое задание

Постановка задачи

Следует разработать программу, выдающую на экран изображение с различными графическими эффектами: квадратиками, случайно разбросанными по экрану, случайными точками, от центра к краям экрана, от краев к центру, моделированием проявления фотографии в проявителе.

В качестве изображения берется файл в графическом формате BMP, PCX, GIF, TIF, WMF или любом другом.

Введение

Понятие "компьютерная графика" существует уже давно. Трудно определить, когда именно и кем были разработаны первые понятия компьютерной графики. Первые вычислительные машины не имели отдельных средств для работы с графикой, однако уже использовались для получения и обработки изображений. Программируя память первых электронных машин, построенную на основе матрицы ламп, можно было получать узоры. В настоящее время компьютерная графика - это огромный мир, такой же, как мир операционных систем, или программирования, это нечто большее, чем просто графика.

Компьютерная графика и эффекты применяются в самых разнообразных сферах деятельности человека:

• в кино;

• в сфере рекламы;

• в полиграфии

• в информационных сферах (телевидение, интернет);

• в сфере игростроения, и многих других.

Киноиндустрия получает ежегодную многомиллионную прибыль от фильмов, в которых использованы современные спецэффекты. Вспомнить хотя бы такие известные фантастические фильмы, как «Люди в черном», «Матрица» и тому подобные. Во всех них использовалась компьютерная графика, создающая эффект максимальной реалистичности происходящего. Смотря на все происходящее в фильме, создается впечатление, что все это было на самом деле.

Компьютерная графика широко используется на телевидении. Все больше и больше последнее время компьютерная графика используется при создании красивых телевизионных заставок, которые вещают на телеканалах. Красивые заставки - это залог успеха телеканала.

Компьютерная графика стала самым основный ресурсом, который затрачивается при создании компьютерных игр.

В мире компьютерной графики отдельную роль занимают графические эффекты, которые применяются к изображениям.

Данная курсовая работа посвящена созданию программы, в которой к исходному изображению применяется один или несколько графических эффектов. В принципе, данная программа может являться частью графического редактора, так как в программе реализуются некоторые его функции обработки изображений.

Описание алгоритмов реализации эффектов для изображения

Наложение телевизионных помех (имитация)

Для имитации превращения изображения в помехи, похожие на телевизионные, мы проходимся по пикселям с координатами, являющимися случайными числами, полученными с помощью генератора случайных чисел, находящимися в пределах от 0 до полной ширины изображения для x, и от 0 до полной высоты изображения для y, и устанавливаем для каждого обрабатываемого пикселя случайные значения параметров цветовых каналов (согласно формату RGB) от 0 до 255.

Случайно разбросанные квадратики

Для получения этого эффекта мы используем матрицу элементов 5x5. Задавая пиксель как центральную точку матрицы случайными координатами x и y, мы обрабатываем все 24 пикселя, лежащие вокруг центрального в удалении не более 2х пикселей, и сам центральный, устанавливая нулевые значения параметров цветовых каналов RGB для каждого пикселя.

Деление изображения линиями на 4 части от центра к краям

Для осуществления такого деления мы используем 4 матрицы элементов 5x5. Задаем пиксель как центральную точку всех 4х матриц с координатами x и y, равными половине ширины изображения по x и половине высоты изображения по y, обрабатываем все 24 пикселя, лежащие вокруг центрального в удалении не более 2х пикселей, и сам центральный, устанавливая нулевые значения параметров цветовых каналов RGB для каждого пикселя.

Далее мы для каждой центральной точки 4х матриц выполняем изменение координат: для первой матрицы увеличиваем y, не изменяя x (линия от центра вверх), для второй матрицы уменьшаем y, не изменяя x (линия от центра вниз), для третьей матрицы увеличиваем x, не изменяя y (линия от центра вправо), для четвертой матрицы уменьшаем x, не изменяя y (линия от центра влево), тем самым выполняя перемещение от центра изображения к его краям всех четырех матриц элементов, обнуляющих значения параметров цветовых каналов RGB для каждого пикселя, создавая тем самым 4 черных линии толщиной в 5 пикселей, делящих изображение ровно на 4 части. Изменение координат происходит до достижения крайними элементами матриц границ изображения.

Деление изображения линиями на 4 части от краев к центру

Алгоритм аналогичен алгоритму деления изображения линиями на 4 части от центра к краям, за исключением начальных координат центральных точек 4х матриц, и изменений их координат.

Начальные координаты задаются следующим образом: для первой матрицы координаты центральной точки равны половине ширины изображения по x, и высоте изображения по y минус 2; для второй матрицы – половине ширины изображения по x, и двум по y; для третьей матрицы – двум по x, и половине высоты изображения по y; для четвертой матрицы – ширине изображения минус 2 по x, и половине высоты изображения по y;

Изменения координат происходят следующим образом: для первой матрицы уменьшаем y, не изменяя x (линия от верхнего края изображения до его центра), для второй матрицы увеличиваем y, не изменяя x (линия от нижнего края изображения до его центра), для третьей матрицы увеличиваем x, не изменяя y (линия от левого края изображения до его центра), для четвертой матрицы уменьшаем x, не изменяя y (линия от правого края изображения до его центра), тем самым выполняя перемещение от краев изображения к его центру всех четырех матриц элементов, обнуляющих значения параметров цветовых каналов RGB для каждого пикселя, создавая тем самым 4 черных линии толщиной в 5 пикселей, делящих изображение ровно на 4 части. Изменение координат происходит до совмещения центральных элементов всех четырех матриц в центре изображения.

Алгоритм установки прозрачности изображения

Для реализации эффекта мы проходимся по пикселям с координатами, являющимися случайными числами, полученными с помощью генератора случайных чисел, находящимися в пределах от 0 до полной ширины изображения для x, и от 0 до полной высоты изображения для y, и устанавливаем для каждого обрабатываемого пикселя значение альфа-канала, определяющего прозрачность цвета, выбранное нами, от 0 до 255 (согласно формату ARGB).

Алгоритм восстановления прозрачного изображения

Алгоритм аналогичен алгоритму установки прозрачности изображения, за исключением того, что параметр альфа-канала для каждого обрабатываемого пикселя устанавливается равным 255 (максимальное значение, соответствующее полной непрозрачности пикселя).

Алгоритм получения негатива изображения

Обрабатываем каждый пиксель изображения. Получение негатива происходит простой заменой каждого значения всех трех RGB-каналов на его дополнение до 255.

Например, R = 255 - R.

Алгоритм фильтрации изображения для ослабления перепадов яркости

Обрабатывается каждый пиксель изображения. Фильтр для усиления яркости изображения основан на фильтре генерации карты изображения. Рассчитывается среднее значение изменения яркости по формуле

d= (|I1 –I5|+|I2–I5|+|I3–I5|+|I4–I5|+|I6–I5|+|I7–I5|+|I8–I5|+|I9–I5|) / 8.

Можно предложить 3 варианта такого фильтра. В первом случае d прибавляется к самому значению яркости текущего пикселя, при этом изображение будет светлеть. Во втором случае d отнимается, при этом изображение будет темнеть. В третьем случае, если яркость меньше порогового значения, то значение d отнимается, иначе прибавляется. В последнем случае цвета изображения стремятся к нижнему и верхнему пределам (произойдет увеличение контрастности).

Алгоритм получения черно-белого изображения

Посредством цикла обрабатывается каждый пиксель изображения. В цикле параметры R G и B каналов суммируются, вычисляется их среднее значение, которое и устанавливается вместо значений R G и B.

Описание программного продукта
1. Программно-аппаратные требования

Данное приложение разрабатывалось и тестировалось при следующей системной конфигурации:

Операционная система Windows 8;
ОЗУ объемом 4096 МБ;
Процессор Intel® Core™ i5-430M 2.26 GHz;
Видеоадаптер, соответствующий стандарту DirectX 11.0;
64bit архитектура;
Установленная платформа Microsoft .NET Framework 4.5.50709

Единственным минимальным требованием к аппаратному обеспечению является разрешение экрана: более, чем 1024x600

Язык и среда программирования

Программный продукт выполнен на языке Visual С#.

В качестве среды разработки был использован продукт Microsoft Visual Studio 2012 версии 11.0.50727.1.

Входные и выходные данные

Входными данными являются изображения таких форматов как BMP, PCX, GIF, TIF, WMF или любых других.

Выходными данными являются изображения, выдаваемые на экран в окне программы, которые так же можно сохранить в форматах JPG либо BMP с разрешением 640*480 в любом доступном месте.

Структура программы

Программный продукт состоит из одного главного окна, являющегося объектом класса Form библиотеки .NET Framework 4.5.

Окно располагает на себе:

графическое окно, в котором по сути происходит демонстрация эффектов – объект класса PictureBox;
управляющие кнопки – объекты класса Button;
пояснительные надписи – объекты класса TextBox;
объект класса OpenFileDialog, предназначенный для инициализации диалога открытия файла;
объект класса SaveFileDialog, предназначенный для инициализации диалога сохранения файла;
1. Описание структурных элементов программы

Основная форма и логика функционирования программы описана в следующих файлах:

Form1.cs
Form1.Designer.cs
Program.cs

Файл Form1.cs содержит описание класса Form, т.е. описание нашей формы, являющейся объектом этого класса. В нем представлена логика методов класса Form, а именно:

private void MakeGray(Bitmap bmp) – метод, отвечающий за обработку изображения, и приведение его в черно-белый вид. В метод передается текущее изображение из picturebox1, результатом работы является вывод в picturebox1 обработанного изображения. Метод был оптимизирован, вместо изображения мы блокируем набор данных изображения в памяти, и работаем с байтами этого изображения в памяти напрямую. После обработки мы копируем набор данных обратно в изображение, и производим разблокировку набора данных изображения в памяти. Оптимизация существенно сократила время обработки изображения;
private Bitmap _IncreaseBrightness(Image original, int sign) – метод, производящий фильтрацию изображения для ослабления перепадов яркости, реализует три варианта (в зависимости от входного параметра sign типа int) использования данного фильтра. В своей работе использует методы private Color _SubColors(Color x, Color y) и private Color _GetSumOfColor(Color[] colors) для вычисления разницы яркости одной из восьми точек вокруг обрабатываемой и обрабатываемой по интенсивности каждого цвета RGB, и рассчета среднего значения изменения яркости d соответственно; В метод передается текущее изображение из picturebox1, результатом работы является вывод в picturebox1 обработанного изображения;
private static Image Kvadr(Image original) с помощью таймера TimerKvadr реализует демонстрацию эффекта случайного разбрасывания квадратиков 5*5 пикселей черного цвета по всему изображению; В метод передается текущее изображение из picturebox1, результатом работы является вывод в picturebox1 обработанного изображения;
private static Image Proz(Image original, int procent) с помощью таймеров TimerProzr100, TimerProzr75, TimerProzr50, TimerProzr25 реализует демонстрацию эффекта превращения изображения в прозрачное на 100, 75, 50 и 25% соотвественно. В метод передается текущее изображение из picturebox1, и процент прозрачности (procent) в виде значения параметра альфа канала ARGB, от 0 до 255. Результатом работы является вывод в picturebox1 обработанного изображения;
private static Image Aproz(Image original) с помощью таймера TimerAprozr реализует демонстрацию эффекта превращения изображения из непрозрачного в прозрачное. В метод передается текущее изображение из picturebox1, результатом работы является вывод в picturebox1 обработанного изображения;
private static Image Invert(Image original) – метод, отвечающий за обработку изображения, и получение его негатива. Метод был оптимизирован, вместо изображения мы блокируем набор данных изображения в памяти, и работаем с байтами этого изображения в памяти напрямую. После обработки мы копируем набор данных обратно в изображение, и производим разблокировку набора данных изображения в памяти. Оптимизация существенно сократила время обработки изображения; В метод передается текущее изображение из picturebox1, результатом работы является вывод в picturebox1 негатива изображения.
private static Bitmap GenerateNoise(Image original) при помощи таймера TimerNoize реализует демонстрацию эффекта превращения изображения в телевизионные помехи. В метод передается текущее изображение из picturebox1, результатом работы является вывод в picturebox1 обработанного изображения;
public Image Kvadrcentrout(Image original) с помощью таймера Timerkvadrcentrout, и public Image Kvadrcentrin(Image original) c помощью таймера Timerkvadrcentrin реализуют демонстрацию эффекта деления изображения на 4 части черными линиями толщиной в 5 пикселей от центра изображения к его краям, и от краев изображения к его центру соответственно. В любой из методов передается текущее изображение из picturebox1, результатом работы является вывод в picturebox1 обработанного изображения;

Кроме того, в файле описаны обработчики событий нажатий на кнопки формы.

Файл Form1.Designer.cs представляет из себя структурированное описание свойств формы и ее элементов таких как физические характеристики (размеры, расположение), значения по умолчанию и др.

Файл Program.cs представляет собой описание главной точки входа для приложения.

Описание интерфейса и инструкция пользователю

Программа разработана для ОС Microsoft Windows версии не ниже XP. Программа может быть запущена из любого места на любом жестком диске. Перед запуском программы следует убедиться в том, что платформа .NET Framework версии не ниже 4.5 установлена. Работа программы в иных условиях не гарантируется. Для запуска программы, следует запустить файл Kursovoi_Kharayan_a31.exe.

Программа состоит из одного основного окна. Для работы с программой был разработан пользовательский интерфейс.

Интерфейс (рис.1.) имеет 17 кнопок управления, которые позволяют загрузить нужное изображение, начать и остановить демонстрацию нужного эффекта, восстановить исходное изображение и сохранить изображение с наложенными на него эффектами в форматах JPG либо BMP с разрешением 640*480 в любом доступном месте.

Рис. 1. Интерфейс программы

В интерфейс входят следующие кнопки:

Кнопки общего назначения:

«Открыть изображение» - служит для открытия файла изображения для обработки;
«Сохранить изображение» - служит для сохранения обработанного файла изображения;
«Остановить демонстрацию» - для эффектов с динамической демонстрацией;
«Восстановить исходное изображение» - для загрузки изображения заново.

Блок кнопок запуска эффектов с динамической демонстрацией

«Наложение телевизионных помех»;
«Случайно разбросанные квадратики»;
2 кнопки «Разделение изображения на 4 части»: от центра к краям и от краев к центру;
4 кнопки «Сделать изображение прозрачным на» на 25, 50, 75 и 100%;
Кнопка «Восстановить прозрачное изображение»;

Блок кнопок запуска эффектов со статической демонстрацией

«Получить негатив изображения»;
«Увеличить яркость»;
«Уменьшить яркость»;
«Увеличить контрастность»;
«Преобразовать изображение в черно-белое».

После запуска программного продукта автоматически загружается изображение реки Малая Коша (центральная часть Тверской области). Пользователь может сразу приступать к применению эффектов для этого изображения. Чтобы загрузить для обработки другое изображение, пользователю следует нажать на кнопку «Открыть изображение».

Запуская динамическую демонстрацию эффекта, пользователю следует помнить, что он может остановить демонстрацию только последнего из запущенных динамических эффектов. Невозможность остановки сразу всех демонстраций предусмотрена для более гибкого комбинирования сразу нескольких эффектов, например, использование эффекта «наложения телевизионных помех» совместно с эффектом «деления изображения на 4 части от центра изображения к его краям» может дать такую интересную картинку, собственно демонстрирующую работу алгоритма «деления изображения на 4 части от центра изображения к его краям» более наглядно:

Рис. 2. Комбинирование эффектов наложения телевизионных помех и деления изображения на 4 части от центра изображения к его краям

Эффекты со статической демонстрацией не используют таймеров, поэтому после запуска их демонстрации пользователь сразу получает готовое статическое изображение с примененным эффектом.

Рис. 3 Исходное изображение с примененным к нему эффектом получения негатива.

Пользователь может в любой момент сохранить текущее изображение, находящееся в окне, вне зависимости от того применяется ли к нему в данный момент эффект со статической или динамической демонстрацией именно в том виде, в котором оно находится на момент нажатия кнопки «Сохранить изображение». После нажатия этой кнопки пользователь может сохранить нужное ему изображение в любое доступное ему место на любом жестком диске в формате BMP либо JPG.

Если пользователь запустит одновременно два и более эффектов с динамической демонстрацией, то для работы с другим изображением без использования тех же эффектов ему придется перезапустить программный продукт.

Заключение

Для курсовой работы была выбрана оптимальная среда Windows и язык разработки, подобрана необходимая литература, изучены и использованы простые алгоритмы для реализации графических эффектов к изображению, была разработана и отлажена программа.

Для реализации алгоритмов использовался такой язык программирования, как Visual С#, использовалась среда программирования Microsoft Visual Studio 2012.

Отладка и тестирование проводились в среде разработки Microsoft Visual Studio 2012.

Результатом данной курсовой работы является программный продукт, который реализует добавление к изображению различных эффектов со статической и динамической демонстрацией.

Программа работает корректно, имеется возможность для добавления других эффектов.

Библиографический список

Н. Б. Культин «Visual C# в задачах и примерах» БХВ-Петербург, 2009

Селянкин В.В., Шилов Д.А. Руководство к лабораторным работам «Двумерная обработка растровых изображений» по курсу «Компьютерная графика», Таганрог: Изд-во ТРТУ, 2001. 28с.

MSDN – сеть разработчиков Microsoft

http://msdn.microsoft.com/ru-ru#fbid=PSBoak1OByD

Приложение 1

Листинг программного продукта:

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Drawing.Imaging;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.Runtime.InteropServices;

namespace Negative

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

public Timer tmr1;

public Image ishImg;

public Int32 ix = 2;

public Int32 iy = 2;

public bool ishImgenable = false;

private void MakeGray(Bitmap bmp) //Преобразование изображения в черно-белое

{

// Задаём формат Пикселя

PixelFormat pxf = PixelFormat.Format24bppRgb;

// Получаем данные картинки

Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);

//Блокируем набор данных изображения в памяти

BitmapData bmpData = bmp.LockBits(rect, ImageLockMode.ReadWrite, pxf);

// Получаем адрес первой линии

IntPtr ptr = bmpData.Scan0;

// Задаём массив из Byte и помещаем в него набор данных.

// int numBytes = bmp.Width * bmp.Height * 3;

//На 3 умножаем - поскольку RGB цвет кодируется 3-мя байтами

int numBytes = bmpData.Stride * bmp.Height;

int widthBytes = bmpData.Stride;

byte[] rgbValues = new byte[numBytes];

// Копируем значения в массив

Marshal.Copy(ptr, rgbValues, 0, numBytes);

// Перебираем пикселы по 3 байта на каждый и меняем значения

for (int counter = 0; counter < rgbValues.Length; counter += 3)

{

int value = rgbValues[counter] + rgbValues[counter + 1] + rgbValues[counter + 2];

byte color_b = 0;

color_b = Convert.ToByte(value / 3);

rgbValues[counter] = color_b;

rgbValues[counter + 1] = color_b;

rgbValues[counter + 2] = color_b;

}

// Копируем набор данных обратно в изображение

Marshal.Copy(rgbValues, 0, ptr, numBytes);

// Разблокируем набор данных изображения в памяти

bmp.UnlockBits(bmpData);

}

private Color _GetSumOfColor(Color[] colors) // Рассчет среднего значения изменения яркости d

{

int rSum = 0;

int gSum = 0;

int bSum = 0;

foreach (var color in colors)

{

rSum += color.R;

gSum += color.G;

bSum += color.B;

}

if (rSum < 0) rSum = 0;

if (rSum > 255) rSum = 255;

if (gSum < 0) gSum = 0;

if (gSum > 255) gSum = 255;

if (bSum < 0) bSum = 0;

if (bSum > 255) bSum = 255;

return Color.FromArgb(rSum, gSum, bSum);

}

private Color _SubColors(Color x, Color y) // Рассчет разницы яркости одной из восьми точек вокруг обрабатываемой и обрабатываемой по интенсивности каждого цвета RGB

{

return Color.FromArgb(Math.Abs(x.R - y.R), Math.Abs(x.G - y.G), Math.Abs(x.B - y.B));

}

private Bitmap _IncreaseBrightness(Image original, int sign)// Изменения яркости

{

Bitmap bmp = new Bitmap(original);

var points = new[] { new Point(-1, 1), new Point(0,1), new Point(1,1),

new Point(-1, 0), new Point(0,0), new Point(1,0),

new Point(-1, -1), new Point(0,-1), new Point(1,-1) };

var outBmp = new Bitmap(bmp.Width, bmp.Height);

int w = bmp.Width;

int h = bmp.Height;

for (int y = 0; y < h; y++)

{

for (int x = 0; x < w; x++)

{

int count = 0;

foreach (var point in points)

{

if (!((x + point.X >= 0) && (x + point.X < w) && (y + point.Y >= 0) && (y + point.Y < h))) ++count;

}

if (count == 0)

{

Color d = _GetSumOfColor(new[]{_SubColors(bmp.GetPixel(x-1, y+1), bmp.GetPixel(x,y)),

_SubColors(bmp.GetPixel(x, y+1), bmp.GetPixel(x,y)),

_SubColors(bmp.GetPixel(x+1, y+1), bmp.GetPixel(x,y)),

_SubColors(bmp.GetPixel(x-1, y), bmp.GetPixel(x,y)),

_SubColors(bmp.GetPixel(x+1, y), bmp.GetPixel(x,y)),

_SubColors(bmp.GetPixel(x-1, y-1), bmp.GetPixel(x,y)),

_SubColors(bmp.GetPixel(x, y-1), bmp.GetPixel(x,y)),

_SubColors(bmp.GetPixel(x+1, y-1), bmp.GetPixel(x,y))

});

double r = 0;

double g = 0;

double b = 0;

if (sign == 0)

{

r = bmp.GetPixel(x, y).R + d.R;

g = bmp.GetPixel(x, y).G + d.G;

b = bmp.GetPixel(x, y).B + d.B;

}

else if (sign == 1)

{

r = bmp.GetPixel(x, y).R - d.R;

g = bmp.GetPixel(x, y).G - d.G;

b = bmp.GetPixel(x, y).B - d.B;

}

else if (sign == 2)

{

if (bmp.GetPixel(x, y).R >= d.R) r = bmp.GetPixel(x, y).R + d.R; else r = bmp.GetPixel(x, y).R - d.R;

if (bmp.GetPixel(x, y).G >= d.G) g = bmp.GetPixel(x, y).G + d.G; else g = bmp.GetPixel(x, y).G - d.G;

if (bmp.GetPixel(x, y).B >= d.B) b = bmp.GetPixel(x, y).B + d.B; else b = bmp.GetPixel(x, y).B - d.B;

}

if (r < 0) r = 0;

if (r > 255) r = 255;

if (g < 0) g = 0;

if (g > 255) g = 255;

if (b < 0) b = 0;

if (b > 255) b = 255;

outBmp.SetPixel(x, y, Color.FromArgb((int)r, (int)g, (int)b));

}

return outBmp;

}

private static Image Kvadr(Image original)// Метод случайного разбрасывания черных квадратиков по изображению

{

Bitmap KvadrBmp = new Bitmap(original);

Random r = new Random();

int PictureHeight = KvadrBmp.Height;

int PictureWidth = KvadrBmp.Width;

int iter = PictureWidth * PictureHeight / 100000;

int i = 0;

while (i < iter)

{

int numpx = r.Next(3, PictureWidth-3);

int numpy = r.Next(3, PictureHeight-3);

KvadrBmp.SetPixel(numpx, numpy, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx-1, numpy-1, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx-1, numpy, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx, numpy-1, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx+1, numpy+1, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx+1, numpy, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx, numpy+1, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx+1, numpy-1, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx-1, numpy+1, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx + 2, numpy, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx, numpy - 2, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx - 2, numpy, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx, numpy + 2, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx - 2, numpy - 2, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx - 1, numpy - 2, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx - 2, numpy - 1, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx + 2, numpy - 2, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx + 2, numpy - 1, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx + 1, numpy - 2, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx + 2, numpy + 2, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx + 1, numpy + 2, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx + 2, numpy + 1, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx - 2, numpy + 2, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx - 1, numpy + 2, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx - 2, numpy + 1, Color.FromArgb(255, 0, 0, 0));

KvadrBmp.SetPixel(numpx, numpy - 2, Color.FromArgb(255, 0, 0, 0));

i++;

}

return KvadrBmp;

}

private static Image Proz(Image original, int procent)// Метод установки прозрачности изображения

{

Bitmap ProzBmp = new Bitmap(original);

Random r = new Random();

int PictureHeight = ProzBmp.Height;

int PictureWidth = ProzBmp.Width;

int iter = PictureWidth * PictureHeight / 100;

int i = 0;

while (i < iter)

{

int numpx = r.Next(0, PictureWidth);

int numpy = r.Next(0, PictureHeight);

int rcanal = ProzBmp.GetPixel(numpx, numpy).R;

int gcanal = ProzBmp.GetPixel(numpx, numpy).G;

int bcanal = ProzBmp.GetPixel(numpx, numpy).B;

ProzBmp.SetPixel(numpx, numpy, Color.FromArgb(procent, rcanal, gcanal, bcanal));

i++;

}

return ProzBmp;

}

private static Image Aproz(Image original)// Метод восстановления прозрачного изображения

{

Bitmap AprozBmp = new Bitmap(original);

Random r = new Random();

int PictureHeight = AprozBmp.Height;

int PictureWidth = AprozBmp.Width;

int iter = PictureWidth * PictureHeight / 100;

int i = 0;

while (i < iter)

{

int numpx = r.Next(0, PictureWidth);

int numpy = r.Next(0, PictureHeight);

int rcanal = AprozBmp.GetPixel(numpx, numpy).R;

int gcanal = AprozBmp.GetPixel(numpx, numpy).G;

int bcanal = AprozBmp.GetPixel(numpx, numpy).B;

AprozBmp.SetPixel(numpx, numpy, Color.FromArgb(255, rcanal, gcanal, bcanal));

i++;

}

return AprozBmp;

}

private static Image Invert(Image original)// Метод получения негатива изображения

{

Bitmap myImage = new Bitmap(original);

BitmapData imageData = myImage.LockBits(new Rectangle(0, 0, myImage.Width, myImage.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);

int stride = imageData.Stride;

IntPtr Scan0 = imageData.Scan0;

unsafe

{

byte* p = (byte*)(void*)Scan0;

int nOffset = stride - myImage.Width * 4;

int nWidth = myImage.Width;

for (int y = 0; y < myImage.Height; y++)

{

for (int x = 0; x < nWidth; x++)

{

p[0] = (byte)(255 - p[0]);

p[1] = (byte)(255 - p[1]);

p[2] = (byte)(255 - p[2]);

p += 4;

}

p += nOffset;

}

myImage.UnlockBits(imageData);

return (Image)myImage;

}

private static Bitmap GenerateNoise(Image original)// Метод создания из изображения имитации телевизионных помех

{

Bitmap finalBmp = new Bitmap(original);

Random r = new Random();

int PictureHeight = finalBmp.Height;

int PictureWidth = finalBmp.Width;

int iter = PictureWidth * PictureHeight / 10;

int i = 0;

while (i < iter)

{

int numc = r.Next(0, 256);

int numpx = r.Next(0, PictureWidth);

int numpy = r.Next(0, PictureHeight);

finalBmp.SetPixel(numpx, numpy, Color.FromArgb(255, numc, numc, numc));

i++;

}

return finalBmp;

}

public Image Kvadrcentrout(Image original)// Метод деления изображения на 4 части черными линиями толщиной в 5 пикселей от центра изображения к его краям

{

Bitmap centroutBmp = new Bitmap(original);

Random r = new Random();

float py = centroutBmp.Height / 2;

float px = centroutBmp.Width / 2;

int x = (int)px;

int y = (int)py;

int numpx = x;

int numpy = y - ix;

centroutBmp.SetPixel(numpx, numpy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 1, numpy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 1, numpy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx, numpy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 1, numpy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 1, numpy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx, numpy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 1, numpy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 1, numpy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 2, numpy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx, numpy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 2, numpy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx, numpy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 2, numpy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 1, numpy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 2, numpy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 2, numpy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 2, numpy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 1, numpy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 2, numpy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 1, numpy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 2, numpy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 2, numpy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 1, numpy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 2, numpy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx, numpy - 2, Color.FromArgb(255, 0, 0, 0));

int numpyy = y + ix;

centroutBmp.SetPixel(numpx, numpyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 1, numpyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 1, numpyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx, numpyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 1, numpyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 1, numpyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx, numpyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 1, numpyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 1, numpyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 2, numpyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx, numpyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 2, numpyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx, numpyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 2, numpyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 1, numpyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 2, numpyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 2, numpyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 2, numpyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 1, numpyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 2, numpyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 1, numpyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx + 2, numpyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 2, numpyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 1, numpyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx - 2, numpyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpx, numpyy - 2, Color.FromArgb(255, 0, 0, 0));

int numpxx = x + iy;

int numpyyy = y;

centroutBmp.SetPixel(numpxx, numpyyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx - 1, numpyyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx - 1, numpyyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx, numpyyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx + 1, numpyyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx + 1, numpyyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx, numpyyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx + 1, numpyyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx - 1, numpyyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx + 2, numpyyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx - 2, numpyyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx, numpyyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx - 2, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx - 1, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx - 2, numpyyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx + 2, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx + 2, numpyyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx + 1, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx + 2, numpyyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx + 1, numpyyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx + 2, numpyyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx - 2, numpyyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx - 1, numpyyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx - 2, numpyyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxx, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

int numpxxx = x - iy;

centroutBmp.SetPixel(numpxxx, numpyyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx - 1, numpyyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx - 1, numpyyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx, numpyyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx + 1, numpyyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx + 1, numpyyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx, numpyyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx + 1, numpyyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx - 1, numpyyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx + 2, numpyyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx - 2, numpyyy, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx, numpyyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx - 2, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx - 1, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx - 2, numpyyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx + 2, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx + 2, numpyyy - 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx + 1, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx + 2, numpyyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx + 1, numpyyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx + 2, numpyyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx - 2, numpyyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx - 1, numpyyy + 2, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx - 2, numpyyy + 1, Color.FromArgb(255, 0, 0, 0));

centroutBmp.SetPixel(numpxxx, numpyyy - 2, Color.FromArgb(255, 0, 0, 0));

return centroutBmp;

}

public Image Kvadrcentrin(Image original)// Метод деления изображения на 4 части черными линиями толщиной в 5 пикселей от краев изображения к его центру

{

Bitmap centroutBmp = new Bitmap(original);

Random r = new Random();

int x = centroutBmp.Width;

int y = centroutBmp.Height;

int numpx = x / 2;

int numpy = y - ix - 1;