首页 > 其他分享 >【cs 50】lab4 & problemset4 -ing

【cs 50】lab4 & problemset4 -ing

时间：2023-07-03 19:45:30浏览次数：39  
标签：width image blurBlue mid height blurGreen problemset4 cs ing

（1）lab4-Smiley

helpers.c

#include "helpers.h"

void colorize(int height, int width, RGBTRIPLE image[height][width])
{
    // Change all black pixels to a color of your choosing
    for(int i=0;i<height;++i){
        for(int j=0;j<width;++j){
            if(image[i][j].rgbtBlue==0x00 && image[i][j].rgbtGreen==0x00 && image[i][j].rgbtRed == 0x00){
                image[i][j].rgbtRed = 0xff;
            }
            else{
                continue;
            }
        }
    }
}

（2）lab4-volume

// Modifies the volume of an audio file

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

// Number of bytes in .wav header
const int HEADER_SIZE = 44;

int main(int argc, char *argv[])
{
    // Check command-line arguments
    if (argc != 4)
    {
        printf("Usage: ./volume input.wav output.wav factor\n");
        return 1;
    }

    // Open files and determine scaling factor
    FILE *input = fopen(argv[1], "r");
    if (input == NULL)
    {
        printf("Could not open file.\n");
        return 1;
    }

    FILE *output = fopen(argv[2], "w");
    if (output == NULL)
    {
        printf("Could not open file.\n");
        return 1;
    }

    float factor = atof(argv[3]);

    // TODO: Copy header from input file to output file
    uint8_t header[HEADER_SIZE];
    fread(&header,sizeof(uint8_t),HEADER_SIZE,input);
    fwrite(&header,sizeof(uint8_t),HEADER_SIZE,output);

    // TODO: Read samples from input file and write updated data to output file
    int16_t buffer;
    while(fread(&buffer,sizeof(int16_t),1,input)){
        buffer *= factor;
        fwrite(&buffer,sizeof(int16_t),1,output);
    }
    // Close files
    fclose(input);
    fclose(output);
}

（3）problemset 4 filter

#include "helpers.h"

// Convert image to grayscale
void grayscale(int height, int width, RGBTRIPLE image[height][width])
{
    BYTE gray;
    BYTE mid;
    for(int i=0;i<height;i++){
        for(int j=0;j<width;j++){
            mid = (image[i][j].rgbtBlue + image[i][j].rgbtGreen + image[i][j].rgbtRed)%0x03;
            if(mid < 1.5){
                gray = (image[i][j].rgbtBlue + image[i][j].rgbtGreen + image[i][j].rgbtRed)/0x03;
            }
            else{
                gray = (image[i][j].rgbtBlue + image[i][j].rgbtGreen + image[i][j].rgbtRed)/0x03+0x01;
            }
            image[i][j].rgbtBlue = image[i][j].rgbtGreen = image[i][j].rgbtRed = gray;
        }
    }
    return;
}

// Convert image to sepia
void sepia(int height, int width, RGBTRIPLE image[height][width])
{
    float _sepiaRed;
    float _sepiaGreen;
    float _sepiaBlue;
    float mid;
    BYTE originalRed;
    BYTE originalGreen;
    BYTE originalBlue;
    BYTE sepiaRed;
    BYTE sepiaGreen;
    BYTE sepiaBlue;
    for(int i=0;i<height;i++){
        for(int j=0;j<width;j++){
            originalRed = image[i][j].rgbtRed;
            originalGreen = image[i][j].rgbtGreen;
            originalBlue = image[i][j].rgbtBlue;
            _sepiaRed = .393 * originalRed + .769 * originalGreen + .189 * originalBlue;
            _sepiaGreen = .349 * originalRed + .686 * originalGreen + .168 * originalBlue;
            _sepiaBlue = .272 * originalRed + .534 * originalGreen + .131 * originalBlue;
            if(_sepiaRed>255)
                _sepiaRed = 255;
            if(_sepiaGreen>255)
                _sepiaGreen = 255;
            if(_sepiaBlue>255)
                _sepiaBlue = 255;
            mid = _sepiaRed - (int)_sepiaRed;
            if(mid<0.5){
                sepiaRed = _sepiaRed;
            }else{
                sepiaRed = _sepiaRed+1;
            }
            mid = _sepiaGreen - (int)_sepiaGreen;
            if(mid<0.5){
                sepiaGreen = _sepiaGreen;
            }else{
                sepiaGreen = _sepiaGreen+1;
            }
            mid = _sepiaBlue - (int)_sepiaBlue;
            if(mid < 0.5){
                sepiaBlue = _sepiaBlue;
            }else{
                sepiaBlue = _sepiaBlue+1;
            }

            image[i][j].rgbtRed = sepiaRed;
            image[i][j].rgbtGreen = sepiaGreen;
            image[i][j].rgbtBlue = sepiaBlue;
        }
    }
    return;
}

// Reflect image horizontally
void reflect(int height, int width, RGBTRIPLE image[height][width])
{
    int mirror = width-1;
    RGBTRIPLE temp;
    for(int i=0;i<height;i++){
        for(int j=0;j<width/2;j++){
            temp = image[i][j];
            image[i][j] = image[i][mirror-j];
            image[i][mirror-j] = temp;
        }
    }
    return;
}

// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{
    RGBTRIPLE temp[height][width];
    BYTE upRed,upGreen,upBlue;
    BYTE downRed,downGreen,downBlue;
    BYTE leftRed,leftGreen,leftBlue;
    BYTE rightRed,rightGreen,rightBlue;
    BYTE upLeftRed,upLeftGreen,upLeftBlue;
    BYTE upRightRed,upRightGreen,upRightBlue;
    BYTE downLeftRed,downLeftGreen,downLeftBlue;
    BYTE downRightRed,downRightGreen,downRightBlue;
    BYTE originalRed;BYTE originalGreen;BYTE originalBlue;
    float blurRed;float blurGreen;float blurBlue;
    BYTE Red;BYTE Blue;BYTE Green;
    int up,down,left,right;
    float count = 9.0;
    float mid = 0.0;
    for(int i=1;i<height-1;i++){
        for(int j=1;j<width-1;j++){
            up = i-1;down = i+1;left = j-1;right = j+1;

            upRed = image[up][j].rgbtRed;upGreen = image[up][j].rgbtGreen;upBlue = image[up][j].rgbtBlue;
            downRed = image[down][j].rgbtRed;downGreen = image[down][j].rgbtGreen;downBlue = image[down][j].rgbtBlue;
            leftRed = image[i][left].rgbtRed;leftGreen = image[i][left].rgbtGreen;leftBlue = image[i][left].rgbtBlue;
            rightRed = image[i][right].rgbtRed;rightGreen = image[i][right].rgbtGreen;rightBlue = image[i][right].rgbtBlue;
            upLeftRed = image[up][left].rgbtRed;upLeftGreen = image[up][left].rgbtGreen;upLeftBlue = image[up][left].rgbtBlue;
            upRightRed = image[up][right].rgbtRed;upRightGreen = image[up][right].rgbtGreen;upRightBlue = image[up][right].rgbtBlue;
            downLeftRed = image[down][left].rgbtRed;downLeftGreen = image[down][left].rgbtGreen;downLeftBlue = image[down][left].rgbtBlue;
            downRightRed = image[down][right].rgbtRed;downRightGreen = image[down][right].rgbtGreen;downRightBlue = image[down][right].rgbtBlue;
            originalRed = image[i][j].rgbtRed;
            originalGreen = image[i][j].rgbtGreen;
            originalBlue = image[i][j].rgbtBlue;

            blurRed = (upRed + downRed + rightRed + leftRed  + upLeftRed + upRightRed + downLeftRed+ downRightRed + originalRed)/count;
            blurGreen = (upGreen + downGreen + rightGreen + leftGreen  + upLeftGreen + upRightGreen + downLeftGreen+ downRightGreen + originalGreen)/count;
            blurBlue = (upBlue + downBlue + rightBlue + leftBlue  + upLeftBlue + upRightBlue + downLeftBlue+ downRightBlue + originalBlue)/count;

            mid = blurRed - (int)blurRed;
            if(mid>=0.5){Red = blurRed + 1;}
            else{Red = blurRed;}
            mid = blurGreen - (int)blurGreen;
            if(mid>=0.5){Green = blurGreen + 1;}
            else{ Green = blurGreen;}
            mid = blurBlue - (int)blurBlue;
            if(mid>=0.5){Blue = blurBlue + 1;}
            else{Blue = blurBlue;}

            temp[i][j].rgbtRed = Red;
            temp[i][j].rgbtGreen = Green;
            temp[i][j].rgbtBlue = Blue;
        }
    }
    count = 6.0;
    for(int j=1;j<width-1;j++){
        down = 1;left = j-1;right = j+1;
        downRed = image[down][j].rgbtRed;downGreen = image[down][j].rgbtGreen;downBlue = image[down][j].rgbtBlue;
        leftRed = image[0][left].rgbtRed;leftGreen = image[0][left].rgbtGreen;leftBlue = image[0][left].rgbtBlue;
        rightRed = image[0][right].rgbtRed;rightGreen = image[0][right].rgbtGreen;rightBlue = image[0][right].rgbtBlue;
        downLeftRed = image[down][left].rgbtRed;downLeftGreen = image[down][left].rgbtGreen;downLeftBlue = image[down][left].rgbtBlue;
        downRightRed = image[down][right].rgbtRed;downRightGreen = image[down][right].rgbtGreen;downRightBlue = image[down][right].rgbtBlue;
        originalRed = image[0][j].rgbtRed;
        originalGreen = image[0][j].rgbtGreen;
        originalBlue = image[0][j].rgbtBlue;

        blurRed = (downRed + rightRed + leftRed  + downLeftRed+ downRightRed + originalRed)/count;
        blurGreen = (downGreen + rightGreen + leftGreen  + downLeftGreen+ downRightGreen + originalGreen)/count;
        blurBlue = (downBlue + rightBlue + leftBlue + downLeftBlue+ downRightBlue + originalBlue)/count;

            mid = blurRed - (int)blurRed;
            if(mid>=0.5){Red = blurRed + 1;}
            else{Red = blurRed;}
            mid = blurGreen - (int)blurGreen;
            if(mid>=0.5){Green = blurGreen + 1;}
            else{ Green = blurGreen;}
            mid = blurBlue - (int)blurBlue;
            if(mid>=0.5){Blue = blurBlue + 1;}
            else{Blue = blurBlue;}



        temp[0][j].rgbtRed = Red;
        temp[0][j].rgbtGreen = Green;
        temp[0][j].rgbtBlue = Blue;
}

    for(int j=1;j<width-1;j++){
        up = height-2;left = j-1;right = j+1;

        upRed = image[up][j].rgbtRed;upGreen = image[up][j].rgbtGreen;upBlue = image[up][j].rgbtBlue;
        leftRed = image[height-1][left].rgbtRed;leftGreen = image[height-1][left].rgbtGreen;leftBlue = image[height-1][left].rgbtBlue;
        rightRed = image[height-1][right].rgbtRed;rightGreen = image[height-1][right].rgbtGreen;rightBlue = image[height-1][right].rgbtBlue;
        upLeftRed = image[up][left].rgbtRed;upLeftGreen = image[up][left].rgbtGreen;upLeftBlue = image[up][left].rgbtBlue;
        upRightRed = image[up][right].rgbtRed;upRightGreen = image[up][right].rgbtGreen;upRightBlue = image[up][right].rgbtBlue;
        originalRed = image[height-1][j].rgbtRed;
        originalGreen = image[height-1][j].rgbtGreen;
        originalBlue = image[height-1][j].rgbtBlue;

        blurRed = (upRed + rightRed + leftRed  + upLeftRed + upRightRed + originalRed)/count;
        blurGreen = (upGreen + rightGreen + leftGreen  + upLeftGreen + upRightGreen  + originalGreen)/count;
        blurBlue = (upBlue + rightBlue + leftBlue  + upLeftBlue + upRightBlue + originalBlue)/count;

       mid = blurRed - (int)blurRed;
            if(mid>=0.5){Red = blurRed + 1;}
            else{Red = blurRed;}
            mid = blurGreen - (int)blurGreen;
            if(mid>=0.5){Green = blurGreen + 1;}
            else{ Green = blurGreen;}
            mid = blurBlue - (int)blurBlue;
            if(mid>=0.5){Blue = blurBlue + 1;}
            else{Blue = blurBlue;}


        temp[height-1][j].rgbtRed = Red;
        temp[height-1][j].rgbtGreen = Green;
        temp[height-1][j].rgbtBlue = Blue;
    }


    for(int i=1;i<height-1;i++){
        up = i-1;down = i+1;right = 1;

        upRed = image[up][0].rgbtRed;upGreen = image[up][0].rgbtGreen;upBlue = image[up][0].rgbtBlue;
        downRed = image[down][0].rgbtRed;downGreen = image[down][0].rgbtGreen;downBlue = image[down][0].rgbtBlue;
        rightRed = image[i][right].rgbtRed;rightGreen = image[i][right].rgbtGreen;rightBlue = image[i][right].rgbtBlue;
        upRightRed = image[up][right].rgbtRed;upRightGreen = image[up][right].rgbtGreen;upRightBlue = image[up][right].rgbtBlue;
        downRightRed = image[down][right].rgbtRed;downRightGreen = image[down][right].rgbtGreen;downRightBlue = image[down][right].rgbtBlue;
        originalRed = image[i][0].rgbtRed;
        originalGreen = image[i][0].rgbtGreen;
        originalBlue = image[i][0].rgbtBlue;

        blurRed = (upRed + downRed + rightRed  + upRightRed +  downRightRed + originalRed)/count;
        blurGreen = (upGreen + downGreen + rightGreen + upRightGreen + downRightGreen + originalGreen)/count;
        blurBlue = (upBlue + downBlue + rightBlue + upRightBlue + downRightBlue + originalBlue)/count;

        mid = blurRed - (int)blurRed;
            if(mid>=0.5){Red = blurRed + 1;}
            else{Red = blurRed;}
            mid = blurGreen - (int)blurGreen;
            if(mid>=0.5){Green = blurGreen + 1;}
            else{ Green = blurGreen;}
            mid = blurBlue - (int)blurBlue;
            if(mid>=0.5){Blue = blurBlue + 1;}
            else{Blue = blurBlue;}

        temp[i][0].rgbtRed = Red;
        temp[i][0].rgbtGreen = Green;
        temp[i][0].rgbtBlue = Blue;
    }

    for(int i=1;i<height-1;++i){
        up = i-1;down = i+1;left = width - 2;

        upRed = image[up][width - 1].rgbtRed;upGreen = image[up][width - 1].rgbtGreen;upBlue = image[up][width - 1].rgbtBlue;
        downRed = image[down][width - 1].rgbtRed;downGreen = image[down][width - 1].rgbtGreen;downBlue = image[down][width - 1].rgbtBlue;
        leftRed = image[i][left].rgbtRed;leftGreen = image[i][left].rgbtGreen;leftBlue = image[i][left].rgbtBlue;
        upLeftRed = image[up][left].rgbtRed;upLeftGreen = image[up][left].rgbtGreen;upLeftBlue = image[up][left].rgbtBlue;
        downLeftRed = image[down][left].rgbtRed;downLeftGreen = image[down][left].rgbtGreen;downLeftBlue = image[down][left].rgbtBlue;

        originalRed = image[i][width - 1].rgbtRed;
        originalGreen = image[i][width - 1].rgbtGreen;
        originalBlue = image[i][width - 1].rgbtBlue;

        blurRed = (upRed + downRed  + leftRed  + upLeftRed +  downLeftRed+ originalRed)/count;
        blurGreen = (upGreen + downGreen  + leftGreen  + upLeftGreen  + downLeftGreen + originalGreen)/count;
        blurBlue = (upBlue + downBlue  + leftBlue  + upLeftBlue  + downLeftBlue + originalBlue)/count;

        mid = blurRed - (int)blurRed;
            if(mid>=0.5){Red = blurRed + 1;}
            else{Red = blurRed;}
            mid = blurGreen - (int)blurGreen;
            if(mid>=0.5){Green = blurGreen + 1;}
            else{ Green = blurGreen;}
            mid = blurBlue - (int)blurBlue;
            if(mid>=0.5){Blue = blurBlue + 1;}
            else{Blue = blurBlue;}

        temp[i][width - 1].rgbtRed = Red;
        temp[i][width - 1].rgbtGreen = Green;
        temp[i][width - 1].rgbtBlue = Blue;
    }

    count = 4.0;
    blurRed = (image[0][0].rgbtRed+image[0][1].rgbtRed+image[1][0].rgbtRed+image[1][1].rgbtRed)/count;
    blurGreen = (image[0][0].rgbtGreen+image[0][1].rgbtGreen+image[1][0].rgbtGreen+image[1][1].rgbtGreen)/count;
    blurBlue = (image[0][0].rgbtBlue+image[0][1].rgbtBlue+image[1][0].rgbtBlue+image[1][1].rgbtBlue)/count;

    mid = blurRed - (int)blurRed;
            if(mid>=0.5){Red = blurRed + 1;}
            else{Red = blurRed;}
            mid = blurGreen - (int)blurGreen;
            if(mid>=0.5){Green = blurGreen + 1;}
            else{ Green = blurGreen;}
            mid = blurBlue - (int)blurBlue;
            if(mid>=0.5){Blue = blurBlue + 1;}
            else{Blue = blurBlue;}

    temp[0][0].rgbtRed = Red;
    temp[0][0].rgbtGreen = Green;
    temp[0][0].rgbtBlue = Blue;

    blurRed =(image[0][width-1].rgbtRed+image[0][width-2].rgbtRed+image[1][width-1].rgbtRed+image[1][width-2].rgbtRed)/count;
    blurGreen =(image[0][width-1].rgbtGreen+image[0][width-2].rgbtGreen+image[1][width-1].rgbtGreen+image[1][width-2].rgbtGreen)/count;
    blurBlue =(image[0][width-1].rgbtBlue+image[0][width-2].rgbtBlue+image[1][width-1].rgbtBlue+image[1][width-2].rgbtBlue)/count;

    mid = blurRed - (int)blurRed;
    if(mid>=0.5){Red = blurRed + 1;}
    else{Red = blurRed;}
    mid = blurGreen - (int)blurGreen;
    if(mid>=0.5){Green = blurGreen + 1;}
    else{ Green = blurGreen;}
    mid = blurBlue - (int)blurBlue;
    if(mid>=0.5){Blue = blurBlue + 1;}
    else{Blue = blurBlue;}

    temp[0][width-1].rgbtRed =Red ;
    temp[0][width-1].rgbtGreen = Green ;
    temp[0][width-1].rgbtBlue = Blue;

    blurRed =(image[height-1][0].rgbtRed+image[height-1][1].rgbtRed+image[height-2][0].rgbtRed+image[height-2][1].rgbtRed)/count;
    blurGreen =(image[height-1][0].rgbtGreen+image[height-1][1].rgbtGreen+image[height-2][0].rgbtGreen+image[height-2][1].rgbtGreen)/count;
    blurBlue = (image[height-1][0].rgbtBlue+image[height-1][1].rgbtBlue+image[height-2][0].rgbtBlue+image[height-2][1].rgbtBlue)/count;

    mid = blurRed - (int)blurRed;
    if(mid>=0.5){Red = blurRed + 1;}
    else{Red = blurRed;}
    mid = blurGreen - (int)blurGreen;
    if(mid>=0.5){Green = blurGreen + 1;}
    else{ Green = blurGreen;}
    mid = blurBlue - (int)blurBlue;
    if(mid>=0.5){Blue = blurBlue + 1;}
    else{Blue = blurBlue;}

    temp[height-1][0].rgbtRed = Red;
    temp[height-1][0].rgbtGreen = Green;
    temp[height-1][0].rgbtBlue =Blue;

    blurRed =(image[height-1][width-1].rgbtRed+image[height-1][width-2].rgbtRed+image[height-2][width-1].rgbtRed+image[height-2][width-2].rgbtRed)/count;
    blurGreen =(image[height-1][width-1].rgbtGreen+image[height-1][width-2].rgbtGreen+image[height-2][width-1].rgbtGreen+image[height-2][width-2].rgbtGreen)/count;
    blurBlue =  (image[height-1][width-1].rgbtBlue+image[height-1][width-2].rgbtBlue+image[height-2][width-1].rgbtBlue+image[height-2][width-2].rgbtBlue)/count;

    mid = blurRed - (int)blurRed;
    if(mid>=0.5){Red = blurRed + 1;}
    else{Red = blurRed;}
    mid = blurGreen - (int)blurGreen;
    if(mid>=0.5){Green = blurGreen + 1;}
    else{ Green = blurGreen;}
    mid = blurBlue - (int)blurBlue;
    if(mid>=0.5){Blue = blurBlue + 1;}
    else{Blue = blurBlue;}

    temp[height-1][width-1].rgbtRed =Red ;
    temp[height-1][width-1].rgbtGreen = Green ;
    temp[height-1][width-1].rgbtBlue =Blue;

    for(int i=0;i<height;++i){
        for(int j=0;j<width;++j){
            image[i][j].rgbtRed = temp[i][j].rgbtRed;
            image[i][j].rgbtGreen = temp[i][j].rgbtGreen;
            image[i][j].rgbtBlue = temp[i][j].rgbtBlue;
        }
    }
    return;
}

 

标签：width,image,blurBlue,mid,height,blurGreen,problemset4,cs,ing
From： https://www.cnblogs.com/zhimingyiji/p/17523816.html

相关文章

  • CSS（五）脱离文档流
    脱离文档流标准文档流导致：高矮不齐，底边对齐空白折叠现象很多空格，都会折叠会一个空格img标签有缝隙脱离文档流：使一个元素脱离标准文档流有三种方式：浮动绝对定位固定定位浮动增加浮动增加一个浮层来放置内容。可以理解为有两层页面，一层为原页面，一层......
  • CSS（六）CSS3新特性
    圆角和阴影圆角，使用border-radius可以给任何元素制作圆角阴影，box-shadow向框添加一个或多个阴影：box-shadow:h-shadowv-shadowblurcolorh-shadow水平阴影的位置v-shadow垂直阴影的位置blur模糊距离color阴影的颜色动画使用百分比来规定变化发生......
  • CSS（七）字体图标
    经常会用到一些图片，但是我们在使用这些图片时，往往会遇到失真的情况，而且图片数量多的话，页面加载很慢，所以我们可以使用字体图标的方式来显示图标，既解决了失真的问题，也解决了图片占用资源的问题。常用资源[阿里字体图标库][https://www.iconfont.cn/]优点：轻量，加载速度快，减少http......
  • SpringBoot 服务接口限流
    前言在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流。限流可以认为服务降级的一种，限流通过限制请求的流量以达到保护系统的目的。一般来说，系统的吞吐量是可以计算出一个阈值的，为了保证系统的稳定运行，一旦达到这个阈值，就需要限制流量并采取一些措施以完成限制流量的......
  • CSS（四）盒子模型
    盒子模型boxmodelCSS盒子模型本质上是一个盒子，封装周围的HTML元素。它包括：margin（外边距）、border（边框）、padding（内边距）、content（内容） 弹性盒子模型flexboxfelxbox是CSS3的一种新的布局模式。是为了让页面适应不同的屏幕大小和设备类型，提供了一种更加有效的方式对容器中的......
  • Jmeter学习之四_kingbaseV8R6数据库的简单验证
    Jmeter学习之四_kingbaseV8R6数据库的简单验证背景周一没去报道,因为我忘记体检了...继续在家进行学习提高自己.jmeter周末时开始看的.今天想着继续研究一下对数据库的处理突然发现人大金仓的官方csdn有一个文档,所以想着偷师,并且总结学习一下.感谢官网的资料.https......
  • SpringBoot项目从0到1配置logback日志打印
    大家好！我是sum墨，一个一线的底层码农，平时喜欢研究和思考一些技术相关的问题并整理成文，限于本人水平，如果文章和代码有表述不当之处，还请不吝赐教。以下是正文！一、写文背景我们在写后端项目的时候，日志打印是必需的。支持SpringBoot项目的日志框架一般有log4j、logback，这二者各有优......
  • Spring框架
    SpringFramework系统架构第一部分：CoreContainer：核心容器核心概念（Ioc/DI）代码书写现状耦合度偏高解决方案使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象IoC（InversionofControl）控制反转对象......
  • springboot中SPI的实现
    在SpringBoot中，可以使用Java的SPI机制来实现SPI。首先，定义一个接口，例如：publicinterfaceMyService{voiddoSomething();}然后，在该接口的实现类中使用Java的SPI注解，例如：publicclassMyServiceImplimplementsMyService{@OverridepublicvoiddoSomethin......
  • prometheus & cloud monitoring
    prometheushttps://prometheus.io/为云监控而生 FrommetricstoinsightPoweryourmetricsandalertingwiththeleadingopen-sourcemonitoringsolution. PrometheusisaCloudNativeComputingFoundationgraduatedproject. 从openstack产生的虚拟机，到k8s......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99