diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4a1949c..8ada8ca 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,8 +18,8 @@ set(LIBRARY_DEPS ${OpenCV_LIBS})
 
 # BUILD
 add_subdirectory(sample_template)
-# Add you directory here
-# add_subdirectory(sample_YOUR_NAME)
+add_subdirectory(sample_ekaterina_maljutina)
+
 
 # REPORT
 message( STATUS "")
diff --git a/sample_ekaterina_maljutina/CMakeLists.txt b/sample_ekaterina_maljutina/CMakeLists.txt
new file mode 100644
index 0000000..006e7f1
--- /dev/null
+++ b/sample_ekaterina_maljutina/CMakeLists.txt
@@ -0,0 +1,7 @@
+set(target "sample_ekaterina_maljutina")
+
+file(GLOB hdrs "*.hpp")
+file(GLOB srcs "*.cpp")
+
+add_executable(${target} ${srcs} ${hdrs})
+target_link_libraries(${target} ${LIBRARY_DEPS})
diff --git a/sample_ekaterina_maljutina/application.cpp b/sample_ekaterina_maljutina/application.cpp
new file mode 100644
index 0000000..6fc2bd2
--- /dev/null
+++ b/sample_ekaterina_maljutina/application.cpp
@@ -0,0 +1,230 @@
+#include "application.hpp"
+#include "processing.hpp"
+#include "ctime"
+#include <opencv2/highgui/highgui.hpp>
+
+using namespace cv;
+
+int Application::parseArguments(int argc, const char **argv, 
+        Application::Parameters &params)
+{
+    if (argc < 2)
+    {
+        return 1;
+    }
+    params.imgFileName = std::string(argv[1]);
+    return 0;
+}
+
+int Application::getFrame(const std::string &fileName, Mat& src)
+{
+    src = imread(fileName);
+    if (src.empty())
+    {
+        return 1;
+    }
+    return 0;
+}
+
+int Application::processFrame(const Mat& src, Mat& dst)
+{
+	
+	
+	processor.processFrame(src, dst, guiState.filter);
+
+    if (dst.empty())
+    {
+        return 1;
+    }
+
+    return 0;
+}
+
+int Application::drawButtons(Mat &display)
+{
+    guiState.onButtonPlace = Rect(20, display.rows - 60, 120, 40);
+    guiState.offButtonPlace = Rect(160, display.rows - 60, 120, 40);
+	guiState.newButtom = Rect(300,display.rows - 60, 120,40);
+	guiState.FilterMEDIAN =  Rect(450,display.rows - 60, 120,40);
+
+	guiState.FilterCVT_CONVERT_GRAY =  Rect(600,display.rows - 60, 120,40);
+	guiState.FilterPIXELIZED =  Rect(750,display.rows - 60, 120,40);
+	guiState.FilterCANNY =  Rect(900 ,display.rows - 60, 120,40);
+
+	rectangle(display, guiState.newButtom, 
+		Scalar(128, 128, 128), CV_FILLED);
+    rectangle(display, guiState.onButtonPlace, 
+              Scalar(128, 128, 128), CV_FILLED);
+    rectangle(display, guiState.offButtonPlace, 
+              Scalar(128, 128, 128), CV_FILLED);
+	rectangle(display, guiState.FilterMEDIAN, 
+              Scalar(128, 128, 128), CV_FILLED);
+
+
+	rectangle(display, guiState.FilterCVT_CONVERT_GRAY, 
+              Scalar(128, 128, 128), CV_FILLED);
+	rectangle(display, guiState.FilterPIXELIZED, 
+              Scalar(128, 128, 128), CV_FILLED);
+	rectangle(display, guiState.FilterCANNY, 
+              Scalar(128, 128, 128), CV_FILLED);
+
+
+    putText(display, "on", 
+        Point(guiState.onButtonPlace.x + guiState.onButtonPlace.width / 2 - 15,
+              guiState.onButtonPlace.y + guiState.onButtonPlace.height / 2 + 10),
+        FONT_HERSHEY_SIMPLEX, 1.0, Scalar(0, 0, 0), 2);
+    putText(display, "off", 
+        Point(guiState.offButtonPlace.x + guiState.offButtonPlace.width / 2 - 20,
+              guiState.offButtonPlace.y + guiState.offButtonPlace.height / 2 + 10),
+        FONT_HERSHEY_SIMPLEX, 1.0, Scalar(0, 0, 0), 2);
+
+
+	putText(display, "my_but", 
+		Point(guiState.newButtom.x + guiState.newButtom.width / 2 - 55,
+              guiState.newButtom.y + guiState.newButtom.height / 2 + 10),
+        FONT_HERSHEY_SIMPLEX, 1.0, Scalar(0, 0, 0), 2);
+
+
+	putText(display, "median", 
+		Point(guiState.FilterMEDIAN.x + guiState.FilterMEDIAN.width / 2 -50,
+              guiState.FilterMEDIAN.y + guiState.FilterMEDIAN.height / 2 + 10),
+        FONT_HERSHEY_SIMPLEX, 1.0, Scalar(0, 0, 0), 2);
+
+	putText(display, "gray", 
+		Point(guiState.FilterCVT_CONVERT_GRAY.x + guiState.FilterCVT_CONVERT_GRAY.width / 2-45,
+              guiState.FilterCVT_CONVERT_GRAY.y + guiState.FilterCVT_CONVERT_GRAY.height / 2 + 10),
+        FONT_HERSHEY_SIMPLEX, 1.0, Scalar(0, 0, 0), 2);
+
+	putText(display, "pixel", 
+		Point(guiState.FilterPIXELIZED.x + guiState.FilterPIXELIZED.width / 2 - 60,
+              guiState.FilterPIXELIZED.y + guiState.FilterPIXELIZED.height / 2 + 10),
+        FONT_HERSHEY_SIMPLEX, 1.0, Scalar(0, 0, 0), 2);
+
+	putText(display, "canny",
+		Point(guiState.FilterPIXELIZED.x + guiState.FilterPIXELIZED.width / 2  + 85,
+              guiState.FilterPIXELIZED.y + guiState.FilterPIXELIZED.height / 2 + 10),
+        FONT_HERSHEY_SIMPLEX, 1.0, Scalar(0, 0, 0), 2);
+
+
+    return 0;
+}
+
+int Application::showFrame(const std::string &caption, 
+        const Mat& src, Mat& dst)
+{
+	
+    if (guiState.state == OffFilter)
+    {
+        src.copyTo(dst);
+    }
+    else if (guiState.state == OnFilter)
+    {
+        processFrame(src, dst);
+    }
+    else
+    {
+        return 1;
+    }
+
+    Mat display(src.rows, src.cols + dst.cols, src.type());
+    Mat srcRoi = display(Rect(0, 0, src.cols, src.rows));
+    src.copyTo(srcRoi);
+    Mat dstRoi = display(Rect(src.cols, 0, dst.cols, dst.rows));
+    dst.copyTo(dstRoi);     
+
+    if (guiState.save)
+	{
+		
+	  // получить текущее время
+		time_t rawtime;
+		struct tm * timeinfo;
+
+		time (&rawtime);
+		timeinfo = localtime(&rawtime);
+
+	
+	  // сгенерировать название изображения
+		std::ostringstream oss;
+		oss << rawtime;
+		string str = oss.str(); 
+		string name_img = "image_sample_ekaterina_maljutina_"  ;  
+		 
+	  // <image_name> - сгенерированное название изображения
+	  //                с меткой текущего времени
+
+		imwrite(name_img  +str +  ".jpg" , display);
+
+		guiState.save = false;
+	  // вызвать функцию сохранения imwrite(<image_name>, display)
+	  // сбросить значение guiState.saveState в false
+	}
+
+    drawButtons(display);
+    
+    namedWindow(caption);  
+    imshow(caption, display);
+    setMouseCallback(caption, onButtonsOnOffClick, &guiState);
+    char key = waitKey(1);
+
+    return key;
+}
+
+void onButtonsOnOffClick(int eventId, int x, int y, int flags, void *userData)
+{
+    if (eventId != EVENT_LBUTTONDOWN)
+    {
+        return;
+    }
+    Application::GUIElementsState *elems = 
+        (Application::GUIElementsState *)userData;
+    if (onButtonClicked(elems->onButtonPlace, x, y))
+    {
+        elems->state = Application::OnFilter;
+        return;
+    }
+    if (onButtonClicked(elems->offButtonPlace, x, y))
+    {
+        elems->state = Application::OffFilter;
+        return;
+    }
+	if (onButtonClicked(elems->newButtom, x, y))
+    {
+		elems->save = true;
+        return;
+    }
+	if (onButtonClicked(elems->FilterMEDIAN, x, y))
+    {
+		elems->state = Application::OnFilter;
+		elems->filter = Processing::MEDIAN;
+        return;
+    }
+	if (onButtonClicked(elems->FilterCVT_CONVERT_GRAY, x, y))
+    {
+		elems->state = Application::OnFilter;
+		elems->filter = Processing::CVT_CONVERT_GRAY;
+        return;
+    }
+	if (onButtonClicked(elems->FilterPIXELIZED, x, y))
+    {
+		elems->state = Application::OnFilter;
+		elems->filter = Processing::PIXELIZED;
+        return;
+    }
+	if (onButtonClicked(elems->FilterCANNY, x, y))
+    {
+		elems->state = Application::OnFilter;
+		elems->filter = Processing::CANNY;
+        return;
+    }
+}
+
+bool onButtonClicked(cv::Rect buttonPlace, int x, int y)
+{
+    if (x < buttonPlace.x || x > buttonPlace.x + buttonPlace.width ||
+        y < buttonPlace.y || y > buttonPlace.y + buttonPlace.height)
+    {
+        return false;
+    }
+    return true;
+}
+
diff --git a/sample_ekaterina_maljutina/application.hpp b/sample_ekaterina_maljutina/application.hpp
new file mode 100644
index 0000000..539b71a
--- /dev/null
+++ b/sample_ekaterina_maljutina/application.hpp
@@ -0,0 +1,63 @@
+#pragma once
+
+#include <string>
+#include <iostream>
+#include <opencv2/core/core.hpp>
+
+#include "processing.hpp"
+
+bool onButtonClicked(cv::Rect buttonPlace, int x, int y);
+void onButtonsOnOffClick(int eventId, int x, int y, int flags, void *userData);
+
+class Application
+{
+ public:
+    enum WindowState
+    {
+        OnFilter,
+        OffFilter
+    };
+    struct Parameters
+    {
+        std::string imgFileName;
+    };
+    struct GUIElementsState
+    {
+        WindowState state;
+        cv::Rect onButtonPlace;
+        cv::Rect offButtonPlace;
+		cv::Rect newButtom;
+
+		cv::Rect FilterMEDIAN;
+		cv::Rect FilterCVT_CONVERT_GRAY;
+		cv::Rect FilterPIXELIZED;
+		cv::Rect FilterCANNY;
+
+		Processing::FilterType filter;
+
+		bool save;
+    };
+    int parseArguments(int argc, const char **argv, Parameters &params);
+    int getFrame(const std::string &fileName, cv::Mat& src);
+    int processFrame(const cv::Mat& src, cv::Mat& dst);
+    int showFrame(const std::string &caption, 
+                  const cv::Mat& src, cv::Mat& dst);
+    friend void onButtonsOnOffClick(int eventId, int x, int y, 
+                                    int flags, void *userData);
+    Application() 
+    { 
+        guiState.state = OnFilter;
+		guiState.save = false;
+
+		guiState.filter =  Processing::MEDIAN;
+
+    };
+
+ private:
+    Processing processor;
+    GUIElementsState guiState;
+
+    int drawButtons(cv::Mat &display);
+    
+    friend bool onButtonClicked(cv::Rect buttonPlace, int x, int y);
+};
diff --git a/sample_ekaterina_maljutina/main.cpp b/sample_ekaterina_maljutina/main.cpp
new file mode 100644
index 0000000..43ff041
--- /dev/null
+++ b/sample_ekaterina_maljutina/main.cpp
@@ -0,0 +1,44 @@
+#include <opencv2/core/core.hpp>
+#include <iostream>
+
+#include "application.hpp"
+
+using namespace std;
+using namespace cv;
+
+enum ErrorCode {
+    OK,
+    WRONG_ARGUMENTS,
+    WRONG_INPUT,
+    CANT_PROCESS
+};
+
+int main(int argc, const char **argv)
+{
+    Application app;
+    Application::Parameters params;
+
+    if (app.parseArguments(argc, argv, params) != 0)
+    {
+        cout << "sample_template <image_name>" << endl;
+        cout << "<image_name> - image name for filtering" << endl;
+        return WRONG_ARGUMENTS;
+    }
+
+    Mat src;
+    if (app.getFrame(params.imgFileName, src) != 0)
+    {
+        cout << "Error: \'src\' image is null or empty!" << endl;
+        return WRONG_INPUT;
+    }
+
+    const std::string caption = "OpenCV Sample";
+    char key = 0;
+    Mat dst(src.rows, src.cols, src.type());
+    while (key != 27) // Esc
+    {
+        key = app.showFrame(caption, src, dst);
+    }
+
+	return OK;
+}
diff --git a/sample_ekaterina_maljutina/processing.cpp b/sample_ekaterina_maljutina/processing.cpp
new file mode 100644
index 0000000..1041d5e
--- /dev/null
+++ b/sample_ekaterina_maljutina/processing.cpp
@@ -0,0 +1,131 @@
+#include "processing.hpp"
+
+#include <opencv2/imgproc/imgproc.hpp>
+
+using namespace cv;
+
+int step = 0;
+int size = 0;
+
+int x = 0;
+int y = 0;
+
+void Processing::processFrame(const cv::Mat& src, cv::Mat& dst,FilterType filter)
+{
+	size +=2;
+    src.copyTo(dst);
+	cv::Rect region;
+	
+	if (( x + step + src.rows/2 + size < src.rows) 
+		&& (y + step + src.cols/2 + size  < src.cols))
+	{
+		
+		cv::Rect r(x + step , y + step, src.rows/2 + size, src.cols/2 + size);
+		region =r;
+
+	}
+	else
+	{
+		if (step != 0)
+			step = 0;
+		x=0;
+		y=0;
+		cv::Rect r(x ,y , src.rows/2 + size, src.cols/2 + size );
+		region =r;
+		size = 0;
+	}
+
+    Mat roi = dst(region);
+
+    const int kSize = 11;
+
+	switch(filter)
+	{
+	case MEDIAN: 
+		{
+			medianBlur(roi, roi, kSize);
+			break;
+		}
+	case CVT_CONVERT_GRAY:
+		{
+			Mat tmp;
+			cvtColor( roi, tmp , CV_BGR2GRAY );
+
+			vector<Mat> ch;
+			ch.push_back(tmp);
+			ch.push_back(tmp);
+			ch.push_back(tmp);
+
+			merge(ch,roi);
+
+			break;
+		}
+	case PIXELIZED:
+		{
+
+			Mat dst = Mat::zeros(roi.size(), CV_8UC3);
+			Mat cir = Mat::zeros(roi.size(), CV_8UC1);
+			int bsize = 10;
+
+			for (int i = 0; i < roi.rows; i += bsize)
+			{
+				for (int j = 0; j < roi.cols; j += bsize)
+				{
+					Rect rect = Rect(j, i, bsize, bsize) & 
+									Rect(0, 0, roi.cols, roi.rows);
+
+					Mat sub_dst(dst, rect);
+					sub_dst.setTo(mean(roi(rect)));
+
+					circle(
+						cir, 
+						Point(j+bsize/2, i+bsize/2), 
+						bsize/2-1, 
+						CV_RGB(255,255,255), -1, CV_AA);
+				}
+			}
+
+			Mat cir_32f;
+			cir.convertTo(cir_32f, CV_32F);
+			normalize(cir_32f, cir_32f, 0, 1, NORM_MINMAX);
+
+			Mat dst_32f;
+			dst.convertTo(dst_32f, CV_32F);
+
+			std::vector<Mat> channels;
+			split(dst_32f, channels);
+			for (int i = 0; i < channels.size(); ++i)
+				channels[i] = channels[i].mul(cir_32f);
+
+			merge(channels, dst_32f);
+			dst_32f.convertTo(dst, CV_8U);
+
+			dst.copyTo(roi);
+
+			break;
+		}
+	case CANNY:
+		{
+			Mat tmp;
+			Canny(roi,tmp,50,150,3);
+			vector<Mat> ch;
+			ch.push_back(tmp);
+			ch.push_back(tmp);
+			ch.push_back(tmp);
+
+			merge(ch,roi);
+
+			break;
+		}
+	default:
+		{
+			medianBlur(roi, roi, kSize);
+			break;
+		}
+	}
+
+    rectangle(dst, region, Scalar(255, 0, 0));
+
+	step = step + 2 ;
+	
+}
diff --git a/sample_ekaterina_maljutina/processing.hpp b/sample_ekaterina_maljutina/processing.hpp
new file mode 100644
index 0000000..96bc2e8
--- /dev/null
+++ b/sample_ekaterina_maljutina/processing.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <opencv2/core/core.hpp>
+
+
+
+class Processing
+{
+ public:
+	 enum FilterType
+	{ 
+		MEDIAN,
+		CVT_CONVERT_GRAY,
+		PIXELIZED,
+		CANNY
+	};
+
+    void processFrame(const cv::Mat& src, cv::Mat& dst,FilterType filter);
+
+	
+};