Inheritance diagram for image_pattern_diagonal:

Collaboration diagram for image_pattern_diagonal:

Public Member Functions
	image_pattern_diagonal (const string &config)

Public Member Functions inherited from image_pattern
	image_pattern ()=default

	image_pattern (const image_pattern &)=delete

	image_pattern (image_pattern &&)=delete

virtual	~image_pattern ()=default

auto	init (int width, int height, enum generator_depth depth) noexcept

image_pattern &	operator= (const image_pattern &)=delete

image_pattern &&	operator= (image_pattern &&)=delete

Private Member Functions
enum generator_depth	fill (int width, int height, unsigned char *data) override

Private Attributes
uint32_t	bg = 0xFF000000U

uint32_t	fg = 0xFFFFFFFFU

int	line_width = 4

int	stride = 80

Additional Inherited Members
Static Public Member Functions inherited from image_pattern
static unique_ptr< image_pattern >	create (string const &pattern, string const &params)

Detailed Description

Definition at line 569 of file video_pattern_generator.cpp.

Constructor & Destructor Documentation

◆ image_pattern_diagonal()

image_pattern_diagonal::image_pattern_diagonal ( const string & config )

inlineexplicit

Definition at line 571 of file video_pattern_generator.cpp.

                                                                       {
                        if (config == "help"s) {
                                col() << "Testcard diagonal usage:\n\t" << SBOLD(SRED("-t testcard:pattern=diagonal") << "[,bg=0x<AABBGGRR<][,fg=0x<AABBGGRR>][,stride=<stride>][,line_width=<width>]") << "\n";
                                throw 1;
                        }
                        if (!config.empty()) {
                                string_view sv = config;
                                while (!sv.empty()) {
                                        auto tok = tokenize(sv, ',');
                                        auto key = tokenize(tok, '=');
                                        auto val = tokenize(tok, '=');
                                        if (key == "bg") {
                                                bg = stol((string) val, nullptr, 0);
                                        } else if (key == "fg") {
                                                fg = stol((string) val, nullptr, 0);
                                        } else if (key == "stride") {
                                                stride = stol((string) val, nullptr, 0);
                                        } else if (key == "line_width") {
                                                line_width = stol((string) val, nullptr, 0);
                                        } else {
                                                throw ug_runtime_error("Testcard diagonal - wrong option: " + string(tok));
                                        }
                                }
                        }
                }

References bg, fg, key, line_width, SBOLD, SRED, stride, tokenize(), and val.

Here is the call graph for this function:

Member Function Documentation

◆ fill()

enum generator_depth image_pattern_diagonal::fill	(	int	width,
		int	height,
		unsigned char *	data )

inlineoverrideprivatevirtual

Return values

bit	depth used by the generator (either 8 or 16)

Implements image_pattern.

Definition at line 598 of file video_pattern_generator.cpp.

                                                                                               {
                        std::fill((uint32_t *)(void *) data, (uint32_t *)(void *) (data + width * height * 4), bg);
                        for(int y = 0; y < height; y++){
                                for(int x = y % stride; x < width - line_width; x += stride){
                                        for(int i = 0; i < line_width; i++){
                                                *((uint32_t *) (void *) (data + (y*width + x + i) * 4)) = fg;
                                        }
                                }
                                for(int x = stride - (y % stride); x < width - line_width; x += stride){
                                        for(int i = 0; i < line_width; i++){
                                                *((uint32_t *) (void *) (data + (y*width + x + i) * 4)) = fg;
                                        }
                                }
                        }
 
                        return generator_depth::bits8;
                }