【开发日志】2023.04 ZENO----Image Processing----CompExtractChanel、CompExtractChanel_RGBA、CompBlur

CompExtractChanel_RGBA

（测试图的绿色不太纯） 

 

 

 

 

 

 

 

 

 

struct CompExtractRGBA : INode {
    virtual void apply() override {
        auto image = get_input<PrimitiveObject>("image");
        auto RGBA = get_input2<bool>("RGBA");
        auto R = get_input2<bool>("R");
        auto G = get_input2<bool>("G");
        auto B = get_input2<bool>("B");
        auto A = get_input2<bool>("A");

        auto &ud = image->userData();
        int w = ud.get2<int>("w");
        int h = ud.get2<int>("h");

//alpha=1
        auto A11 = std::make_shared<PrimitiveObject>();
        A11->verts.resize(image->size());
        A11->userData().set2("isImage", 1);
        A11->userData().set2("w", w);
        A11->userData().set2("h", h);
        A11->verts.add_attr<float>("alpha");
        for(int i = 0;i < image->size();i++){
            A11->verts.attr<float>("alpha")[i] = 1;
        }
        std::vector<float> &Alpha = A11->verts.attr<float>("alpha");

//alpha=0
        auto A1 = std::make_shared<PrimitiveObject>();
        A1->verts.resize(image->size());
        A1->userData().set2("isImage", 1);
        A1->userData().set2("w", w);
        A1->userData().set2("h", h);
        A1->verts.add_attr<float>("alpha");
        for(int i = 0;i < image->size();i++){
            A1->verts.attr<float>("alpha")[i] = 0;
        }

        if(image->verts.has_attr("alpha")){
            A1->verts.attr<float>("alpha") = image->verts.attr<float>("alpha");
            std::vector<float> &Alpha = image->verts.attr<float>("alpha");
        }

        float R1=0,G1=0,B1=0;

        if(R) {
            for (auto i = 0; i < image->verts.size(); i++) {
                R1 = image->verts[i][0];
                A1->verts[i][0] = R1 * ((Alpha[i] == 1) ? 1 : 0);
                A1->verts.attr<float>("alpha")[i] = ((R1 != 0) ? 1 : A1->verts.attr<float>("alpha")[i]);
            }
        }

        if(G) {
            for (auto i = 0; i < image->verts.size(); i++) {
                G1 = image->verts[i][1];
                A1->verts[i][1] = G1 * ((Alpha[i] == 1) ? 1 : 0);
                A1->verts.attr<float>("alpha")[i] = ((G1 != 0) ? 1 : A1->verts.attr<float>("alpha")[i]);
            }
        }
        if(B) {
            for (auto i = 0; i < image->verts.size(); i++) {
                B1 = image->verts[i][2];
                A1->verts[i][2] = B1 * ((Alpha[i] == 1) ? 1 : 0);
                A1->verts.attr<float>("alpha")[i] = ((B1 != 0) ? 1 : A1->verts.attr<float>("alpha")[i]);
            }
        }
        if(A) {
            if (image->verts.has_attr("alpha")) {
                for (auto i = 0; i < image->verts.size(); i++) {
                    float A = Alpha[i];
                    A1->verts[i][0] = A;
                    A1->verts[i][1] = A;
                    A1->verts[i][2] = A;
                }
            }
        }
        set_output("image", A1);
    }
};
ZENDEFNODE(CompExtractRGBA, {
    {
        {"image"},
        {"bool", "RGBA", "0"},
        {"bool", "R", "0"},
        {"bool", "G", "0"},
        {"bool", "B", "0"},
        {"bool", "A", "0"},
    },
    {
        {"image"}
    },
    {},
    { "comp" },
});

CompExtractChanel

 

 

 

 

 

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" },
});

ExtractRGBAED(deprecated)

 

 

 

 

 

 

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 ImageEditBlur : 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(ImageEditBlur, {
    {
        {"image"},
        {"enum Blur GaussianBlur MedianBlur BilateralFilter", "mode", "Blur"},
        {"float", "xsize", "1"},
        {"float", "ysize", "1"},
    },
    {
        {"image"}
    },
    {},
    { "comp" },
});