[Development Log] 2023.04 ZENO----Image Processing----ExtractRGBA, EdgeDetect

ExtractRGBA

Input:

Output:

RGBA

R

G

B

A

struct ExtractRGBA : INode {
    virtual void apply() override {
        auto image = get_input<PrimitiveObject>("image");
        auto RGBA = get_input2<std::string>("RGBA");

        if(RGBA == "RGBA") {}
        if(RGBA == "R") {
            for (auto i = 0; i < image->verts.size(); i++) {
                float R = image->verts[i][0];
                image->verts[i][0] = R;
                image->verts[i][1] = R;
                image->verts[i][2] = R;
            }
        }
        if(RGBA == "G") {
            for (auto i = 0; i < image->verts.size(); i++) {
                float G = image->verts[i][1];
                image->verts[i][0] = G;
                image->verts[i][1] = G;
                image->verts[i][2] = G;
            }
        }
        if(RGBA == "B") {
            for (auto i = 0; i < image->verts.size(); i++) {
                float B = image->verts[i][2];
                image->verts[i][0] = B;
                image->verts[i][1] = B;
                image->verts[i][2] = B;
            }
        }
        if(RGBA == "A") {
            if (image->verts.has_attr("alpha")) {
                auto &Alpha = image->verts.attr<float>("alpha");
                for (auto i = 0; i < image->verts.size(); i++) {
                    float A = Alpha[i];
                    image->verts[i][0] = A;
                    image->verts[i][1] = A;
                    image->verts[i][2] = A;
                }
            }
        }
        set_output("image", image);
    }
};
ZENDEFNODE(ExtractRGBA, {
    {
        {"image"},
        {"enum RGBA R G B A", "RGBA", "RGBA"},
    },
    {
        {"image"}
    },
    {},
    { "comp" },
});

CompBlur

Input:

{"image"},
{"enum Blur GaussianBlur MedianBlur BilateralFilter", "mode", "mode"},
{"float", "xsize", "1"},
{"float", "ysize", "1"},

Output:

Blur

size(5,5)

size(50,5)

 GaussianBlur KSize(10,10)

 MedianBlur KSize(4,4)

 BilateralFilter KSize(4,4)

struct CompBlur : INode {
    virtual void apply() override {
        auto image = get_input<PrimitiveObject>("image");
        auto mode = get_input2<std::string>("mode");
        auto xsize = get_input2<int>("xsize");
        auto ysize = get_input2<int>("ysize");
        auto &ud = image->userData();
        int w = ud.get2<int>("w");
        int h = ud.get2<int>("h");
        cv::Mat imagecvin(h, w, CV_32FC3);
        cv::Mat imagecvout(h, w, CV_32FC3);
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < w; j++) {
                vec3f rgb = image->verts[i * w + j];
                imagecvin.at<cv::Vec3f>(i, j) = {rgb[0], rgb[1], rgb[2]};
            }
        }
        if(mode=="Blur"){
            cv::blur(imagecvin,imagecvout,cv::Size(xsize,ysize),cv::Point(-1,-1));
        }
        if(mode=="GaussianBlur"){
            if(xsize%2==0){
                xsize += 1;
            }
            cv::GaussianBlur(imagecvin,imagecvout,cv::Size(xsize,xsize),1.5);
        }
        if(mode=="MedianBlur"){
            if(xsize%2==0){
                xsize += 1;
            }
            cv::medianBlur(imagecvin,imagecvout,xsize);
        }
        if(mode=="BilateralFilter"){
            if(xsize%2==0){
                xsize += 1;
            }
            cv::bilateralFilter(imagecvin,imagecvout,xsize,75,75);
        }
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < w; j++) {
                cv::Vec3f rgb = imagecvout.at<cv::Vec3f>(i, j);
                image->verts[i * w + j] = {rgb[0], rgb[1], rgb[2]};
            }
        }
        set_output("image", image);
    }
};

ZENDEFNODE(CompBlur, {
    {
        {"image"},
        {"enum Blur GaussianBlur MedianBlur BilateralFilter", "mode", "mode"},
        {"float", "xsize", "1"},
        {"float", "ysize", "1"},
    },
    {
        {"image"}
    },
    {},
    { "comp" },
});

EdgeDetect