ImageProcessor/image_processor.cpp at master · RoyalMirMak/ImageProcessor · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#include "BMPDownloader.h"
#include "BMPUploader.h"
#include "Exceptions.h"
#include "filters/FilterBlur.h"
#include "filters/FilterCrop.h"
#include "filters/FilterEdge.h"
#include "filters/FilterGlass.h"
#include "filters/FilterGrayscale.h"
#include "filters/FilterNegative.h"
#include "filters/FilterSharpening.h"
#include "filters/Filter.h"

#include <iostream>
#include <memory>
#include <set>
#include <string>

void PrintReference() {
    std::ifstream reference_file("reference.txt");

    std::string line;
    while (getline(reference_file, line)) {
        line.pop_back();
        std::cout << line << '\n';
    }
}

void CreateFilters(std::vector<std::shared_ptr<Filter>>& filters, int argc, char** argv) {
    const std::set<std::string> code_words = {"-crop", "-gs", "-neg", "-sharp", "-edge", "-blur", "-glass"};
    for (size_t i = 3; i < static_cast<size_t>(argc); ++i) {
        std::string type = argv[i];
        if (code_words.find(type) == code_words.end()) {
            std::string message = "No filter named: " + type;
            throw ProgramArgumentsException(message);
        }
        std::vector<char*> parameters;
        i++;
        while (i < static_cast<size_t>(argc)) {
            std::string argument = argv[i];
            if (code_words.find(argument) != code_words.end()) {
                i--;
                break;
            }
            parameters.push_back(argv[i]);
            ++i;
        }
        if (type == "-crop") {
            filters.push_back(std::make_shared<FilterCrop>(parameters));
        } else if (type == "-gs") {
            filters.push_back(std::make_shared<FilterGrayscale>(parameters));
        } else if (type == "-neg") {
            filters.push_back(std::make_shared<FilterNegative>(parameters));
        } else if (type == "-sharp") {
            filters.push_back(std::make_shared<FilterSharpening>(parameters));
        } else if (type == "-edge") {
            filters.push_back(std::make_shared<FilterEdge>(parameters));
        } else if (type == "-blur") {
            filters.push_back(std::make_shared<FilterBlur>(parameters));
        } else if (type == "-glass") {
            filters.push_back(std::make_shared<FilterGlass>(parameters));
        }
    }
}

void ValidateParameters(std::vector<std::shared_ptr<Filter>>& filters) {
    for (const std::shared_ptr<Filter>& filter : filters) {
        filter->ValidateParameters();
    }
}

void Apply(std::vector<std::shared_ptr<Filter>>& filters, Image& image) {
    for (const std::shared_ptr<Filter>& filter : filters) {
        std::cout << "Started to applying \"" << filter->GetName() << "\"";
        if (filter->GetParametersNum()) {
            std::cout << " (" << filter->GetParametersValuesString() << ")";
        }
        std::cout << "..." << '\n';
        filter->Apply(image);
        std::cout << "\"" << filter->GetName() << "\" applied" << '\n';
    }
}

int main(int argc, char** argv) {
    if (argc == 1) {
        PrintReference();
        return 0;
    }

    BMPDownloader downloader(argv[1]);
    BMPUploader uploader(argv[2]);
    Image image;

    try {
        downloader.OpenFile();
        uploader.OpenFile();
        std::vector<std::shared_ptr<Filter>> filters;
        CreateFilters(filters, argc, argv);

        std::string info_todo = "Filters to apply: ";
        for (const std::shared_ptr<Filter>& filter : filters) {
            info_todo += "\"" + filter->GetName() + "\"";
            info_todo += ", ";
        }
        info_todo.pop_back();
        info_todo.pop_back();
        std::cout << info_todo << '\n';

        ValidateParameters(filters);

        downloader.SaveBMPToImage(image);
        downloader.CloseFile();

        Apply(filters, image);

        uploader.SaveImageToBMP(image);
        uploader.CloseFile();
    } catch (const std::exception& exception) {
        std::cerr << "Program failed" << '\n';
        std::cerr << exception.what() << '\n';
        delete exception.what();
        std::cerr << "Run the program without arguments to see the reference" << '\n';
        return 1;
    }
    return 0;
}