2d Computer Graphics in Modern C and Standard Library Compress

2D Computer Graphics in modern c++ and
standard library
Håkan Blomqvist
This book is for sale at http://leanpub.com/2dcomputergraphicsinmoderncandstandardlibrary
This version was published on 2023-05-14
This is a Leanpub book. Leanpub empowers authors and publishers with the Lean Publishing
process. Lean Publishing is the act of publishing an in-progress ebook using lightweight tools and
many iterations to get reader feedback, pivot until you have the right book and build traction once
you do.
© 2023 Håkan Blomqvist

Contents
1 2D Drawing Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1 History . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Compile Code Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Prerequisite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Draw Pixels with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3 Texture Generation with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4 Time to draw some lines with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . 11
5 There are no straight curves, only curved lines . . . . . . . . . . . . . . . . . . . . . . . . . . 19
6 Rectangles with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
7 Circles with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
8 Triangles with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
9 Animation with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
10 Drawing Charts and a Font . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
11 Presentation, Collaboration, and Investigation . . . . . . . . . . . . . . . . . . . . . . . . . . 36

11.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
11.2 Draw a bar chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
11.3 Draw a pie chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
11.4 Draw a donut chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
11.5 Draw a table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
11.6 Draw a more advanced chart 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
11.7 Draw a more advanced chart 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
11.8 Collaboration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
11.9 Investigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
12 PPM++ header-only library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

CONTENTS
13 In the Rearview Mirror . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
14 Appendix A: Source Code Listings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

1 2D Drawing Basics
We have all been there when you just want to present som data in a nice and graphical way. You
start by implementing a GUI library so that you can set up a canvas to draw on… but then what?
Or you download and build a library that can handle reading and writing PNG images, as you need
lossless images. Or you do the same just to find out a files entropy. Or you’re coding on a game
and want to test the look of animation sprites in a parallax setting. What ever the reason is… it’s
too complicated to do and takes more time than you would consider doing. So no presentation, no
collaboration, and no investigation using graphics.
It should just be easy to create graphics in standard C++. And this book is all about that. How do
we draw a pixel, a line, or a circle? That is questions we going to answer.
1.1 History
2D Drawings with computers started out in, as most things computer related, in academia. It was
first created as a visualization tool for scientists and engineers in US government and US corporate
research centers such as Bell Labs and Boeing in the 1950s. Later the tools would be developed at
Universities in the 60s and 70s at places such as Ohio State University, MIT, University of Utah,
Cornell, North Carolina and the New York Institute of Technology. The early breakthroughs that
took place in academic centers continued at research centers such as the famous Xerox PARC in the
1970s. These efforts broke first into broadcast video graphics and then major motion pictures in the
late 70¹s and early 1980s. Computer graphic research continues today around the world, now joined
by the research and development departments of entertainment and production companies.
Since 1974 ACM SIGGRAPH has evolved to become an international community of researchers,
artists, developers, filmmakers, scientists, and business professionals who share an interest in
computer graphics and interactive techniques. Each year the latest and greatest with this research
gets presented.
1.2 Standard Library

There are no support for drawing in the Standard Library. There are no media support what so ever
in the Standard Library. And there are no need to. With the tools available to us, we will be able to
draw pixels, lines and circles.
1 2D Drawing Basics 3
1.3 Compile Code Examples

All code is compiled using clang++, but of course works fine with g++. Everything is C++17 except
std::lerp, as its part of C++20 (a C++17 solution will be presented).
1.4 Prerequisite
You’ll need to already know how to program in C++. This book is about how to draw and and not
about how to program.
2 Draw Pixels with Standard Library
We’re using RGB elements to draw a pixel in C++. To handle RGB elements as one unit for
convenience there is something called std::tuple.
Reference: https://en.cppreference.com/w/cpp/utility/tuple e.g. a function that takes three integers
as input and returns it as a tuple
01_tuples.cpp demonstrates the usage of ‘std::tuple’ in C++17. It uses a tuple to store and
manipulate RGB color elements as a single entity. The code includes the ‘’ headers and defines
a function ‘get_rgb_elements_as_a_tuple’ that takes three integers (r, g, and b) and returns a tuple
containing these integers.
The ‘main’ function initializes three sets of RGB values (r1, g1, b1, r2, g2, b2, and r3, g3, b3). Initially,
only the first set (r1, g1, b1) is given values, while the other two sets are initialized to 0.
The code then prints the initial RGB values of all three sets. Next, it calls ‘get_rgb_elements_as_-
a_tuple’ with the first set of RGB values (r1, g1, b1) and assigns the returned tuple to ‘rgb’.
Two different methods are then used to “unroll” the ’ ’ tuple into the other two sets of RGB values:
1. “unroll #1”: Using ‘std::get’ to access individual elements of the tuple by index and assigning
them to r2, g2, and b2.
2. “unroll #2”: Using ‘std::tie’ to unpack the tuple into r3, g3, and b3.
After each unroll, the RGB values of all three sets are printed to verify that the tuple has been
correctly unpacked into the second and third sets of RGB values.
take a look in Appendix A: 01_tuples.cpp
Now that we know how to store and unroll a tuple of rgb elements. Let’s talk about adding rgb
tuples to an image — to set a pixel where we want it to be in the image.
But, before that we need to talk about the way computers memory (1D) is physically represented
and the representation of an image (2D). To know where to store the tuple we need to translate (2D)
into (1D). To store the pixel at a certain x and y in the image, but in memory.
index = x + width ∗ y
2 Draw Pixels with Standard Library 5
X + width * Y = 2 + 10 * 3 = 32 Index = 32
Let’s create a function that handles the index-calculations for us. A function that takes X and Y as
input and returns the index.
Or, take a look in Appendix A: 02_index.cpp
Besides calculating index we need to know how many tuples with we need to store in a std::vector
for a beforehand defined width and height of an image. For instance, an image that has a width of
640 and a height of 360 is 640 * 360 (230400) in size for a std::vector with those dimensions.
Reference: https://en.cppreference.com/w/cpp/container/vector As always we need to include the
header: #include
To set the vector container size we calculate it by multiplying the image width times the height.
We use the Resize function in std::vector to set the size of the vector. Then we can use the vectors
operator[] and operator= for index and assigns.
Also, why not assign the color black to all the pixels while we are at it, as a clear image function.
For the source code, take a look in Appendix A: 03_calcsize.cpp
Note that this code example uses float for the rgb elements. We do that as it’s preferred later when
we work with colors and that red, green and blue are a float number between 0.0 - 1.0 and not an
integer.Enough with the calculations of metadata about the image. It’s time to draw some pixels
and save it into a textile. Yes, there are a few image formats that are text based. In this book we’re
going to use PPM file format. This graphics format comes from the open source Netpbm project that
is several graphics programs and a programming library — used mainly in the Unix world. PPM
stands for Portable PixMap format and is portable due to its written as ASCII (Type: P3). A PPM
file consists of two parts: a header and the image data. Don’t worry about the it being ASCII, PPM
can be converted to PNG, JPG or any other format. Here’s how the PPM format looks like as ASCII:
1 P3 # "P3" means this is a RGB color image in ASCII

2 3 2 # "3 2" is the width and height of the image in pixels
3 255 # "255" is the maximum value for each color
4 # The part above is the header
5 # The part below is the image data: RGB triplets
6 255 0 0 # red
7 0 255 0 # green
8 0 0 255 # blue
9 255 255 0 # yellow
10 255 255 255 # white
11 0 0 0 # black
The header starts with the ”P3” indicator. Second line contains the width and height of the image
separated with a whitespace. Third line has the number 255 stated, this is going to be used for all
examples in this book. The 255 is about the max value for each rgb element. And as we see below
the header, each pixel is represented as three integer values between 0 - 255 for rgb.
Include header: #include Reference: https://en.cppreference.com/w/cpp/io/basic_fstream
For the source code, take a look in Appendix A: 04_helloworld.cpp
04_helloworld_square.ppm
04_helloworld.ppm
That’s great, but even more awesome if we also could read a PPM image too.
For the source code, take a look in Appendix A: 05_randomwalker.cpp
05_randomwalker.ppm
Now, we have a lot of code to go through in the 05 example. There are one new header and few new
functions that needs some explanation.
Example 05 was not only about reading a PPM file. We implemented a random walker. Let go
through the code function by function.
Reference: https://en.cppreference.com/w/cpp/header/random
Add random header to the file: #include
Following functions are new:
• walker
• update_x_and_y
• read_image
• get_color
• get_width_and_height
• startsWithCaseInsensitive
We start by reading 04_helloworld.ppm into image1 and at the same time set width and height from
the PPM file using get_width_and_height. read_image uses the helper function startsWithCaseIn-
sensitive to sort through the PPM data. get_color is used to read the rgb color.
We use the walker function to implement a random walker algorithm. Walker uses random function
to randomize the walker. For each walker generation we use the update_x_and_y function to move
the walker in a random direction.
3 Texture Generation with Standard
Library
Neat, now we can draw pixels. Let’s play around with that a bit and generate different types of
textures that can be useful to have.
Let’s generate textures by using boolean XOR (Exclusive-OR) AND and OR.
The code generates and saves three different textures based on bitwise operations: XOR, AND, and
OR. To achieve this, it defines several functions to create, manipulate, and save the images. The
‘get_index’ function is responsible for converting 2D grid coordinates (x, y) into a 1D array index,
while the ‘calc_size’ function calculates the total number of elements in a 2D grid. The ‘clear_-
image’ function sets all the pixels of an image to a given color, effectively clearing the image.
The code also provides three functions to create different textures: ‘draw_xor’, ‘draw_and’, and
‘draw_or’. Each function iterates through the image’s pixels and calculates the corresponding
bitwise operation (XOR, AND, or OR) on the x and y coordinates of each pixel. The resulting value
is then used as the color intensity for that pixel.
In the ‘main’ function, the program starts by initializing the image vector and color tuple, followed
by resizing the image vector based on the calculated size. The image is then cleared using a dark
blue color. After that, the XOR texture is generated and saved to the “06_xor_texture.ppm” file.
Subsequently, the AND texture is generated and saved to the “06_and_texture.ppm” file. Finally,
the OR texture is generated and saved to the “06_or_texture.ppm” file.
For the source code, take a look in Appendix A: 06_xor_and_or_texture.cpp
06_xor_texture.ppm
3 Texture Generation with Standard Library 9
06_and_texture.ppm
06_or_texture.ppm
XOR, AND and OR type of textures are the simplest ones. It’s just x XOR y, x AND y, or x OR y.
These textures are nice to have if you just want to do an example. Excellent for prototyping use.
Procedural texture generation is another way to create textures. With random noise we can generate
textures like clouds, marble, and wood.
Reference: https://en.cppreference.com/w/cpp/numeric/math/fabs
This code generates and saves three different textures: Clouds, Marble, and Wood. It includes several
functions to create, manipulate, and save images. The ‘get_index’, ‘calc_size’, ‘clear_image’, and
‘save_image’ functions were explained in the previous response, and they serve the same purpose
here. Additionally, a new function ‘generate_noise’ is introduced, which fills a noise vector with
random values in the range of 0.0 to 1.0.
The ‘smooth_noise’, ‘turbulence’, and texture generation functions (‘generate_cloud’, ‘generate_-
marble’, and ‘generate_wood’) are the core of this code. The ‘smooth_noise’ function calculates a
bilinear interpolation of the noise values at a given position, while the ‘turbulence’ function sums
up the smooth noise values at different scales to generate more complex patterns.
The ‘generate_cloud’ function uses the ‘turbulence’ function to create a cloud-like texture. In
contrast, the ‘generate_marble’ function calculates a sine pattern that is distorted by turbulence to
mimic the appearance of marble. Finally, the ‘generate_wood’ function creates a wood-like texture
by calculating the distance from the center of the image and applying a sine pattern combined with
turbulence.
In the ‘main’ function, the program initializes the noise and image vectors and resizes them based on
3 Texture Generation with Standard Library 10
the calculated size. The image is then cleared using a dark blue color. The noise vector is generated,
and the Cloud texture is created and saved to the “07_cloud_texture.ppm” file. Subsequently, the
Marble texture is generated and saved to the “07_marble_texture.ppm” file. Finally, the Wood texture
is generated and saved to the “07_wood_texture.ppm” file.
For the source code, take a look in Appendix A: 07_clouds_marble_wood_texture.cpp
07_cloud_texture.ppm
07_marble_texture.ppm
07_wood_texture.ppm
Uses bilinear interpolation to smooth the noise. Turbulence is added for marble and wood.
Procedural generation in itself is an interesting topic.
4 Time to draw some lines with
Standard Library
Well, not yet, first we go through some theory about light and color that is good to know.
A C++ program designed to manipulate images in the PPM format, specifically the P3 (ASCII) format.
It includes various functions to perform image manipulation tasks such as creating a negative image,
adjusting brightness and darkness, converting to grayscale, swapping color channels, and blending
two images. The program uses the Standard Library and has a main function to perform user-
specified manipulations on an input image file and save the result to an output file.
The code begins by importing necessary headers and declaring several utility functions like
‘startsWithCaseInsensitive’, ‘get_index’, ‘calc_size’, ‘get_width_and_height’, and ‘get_color’.
These functions help with string manipulation, getting an index in a 1D array representing a 2D
image, calculating the size of an image, and extracting image dimensions and color values from
strings.
The ‘read_image’ function reads an image from a file and stores it as a vector of tuples with float
values representing the red, green, and blue (RGB) components of each pixel. The function reads
the file line by line, determining the file format, dimensions, and maximum color value, and then
populates the image vector with the pixel data.
Several functions perform image manipulations like ‘negative_image’, ‘double_as_dark’,
‘onefive_as_dark’, ‘twice_as_bright’, ‘add_for_brighter’, ‘sub_for_darker’, ‘greyscale_image’,
‘zero_gb_image’, ‘r_zero_b_image’, ‘rg_zero_image’, ‘grb_image’, ‘bgr_image’, ‘rrb_image’,
and ‘blended_two_images’. These functions take an image (vector of tuples) and its dimensions
as input and modify the image in place. Some functions also take additional parameters like the
blending factor ‘alpha’ for ‘blended_two_images’.
The main function of the program reads an input image file, performs the user-specified image
manipulations using the functions mentioned above, and writes the modified image to an output
file. The main function also takes care of validating the user input and making sure the provided
parameters are valid.
For the source code, take a look in Appendix A: 08_light_and_color.cpp
For every image generated, 04_helloworld.ppm get’s reread.
4 Time to draw some lines with Standard Library 12
08_negative_image.ppm
Subtraction Eg. original color rgb(203, 37, 101) as negative: rgb(255-203, 255-37, 255-101) which is
the same as: rgb(52, 218, 154).
08_double_as_dark.ppm
Division Eg. rgb(203, 37, 101) as double as dark: rgb(203/2, 37/2, 101/2) which is the same as: rgb(101,
18, 50).
08_onefive_as_dark.ppm
Division Eg. rgb(203, 37, 101) as 1.5 as dark: rgb(203/1.5, 37/1.5, 101/1.5) which is the same as:
rgb(135, 25, 67).
08_twice_as_bright.ppm
Multiplication Eg. rgb(203, 37, 101) as twice as bright: rgb(203x2, 37x2, 101x2) which is the same
as: rgb(255, 74, 202).
08_add_for_brighter.ppm
Addition Eg. rgb(203, 37, 101) add for brighter: rgb(203+30, 37+30, 101+30) which is nthe same as:
Eg. rgb(233, 67, 131)
08_sub_for_darker.ppm
Subtraction Eg. rgb(203, 37, 101) sub for darker: rgb(203-30, 37-30, 101-30) which is nthe same as:
Eg. rgb(173, 7, 71)
08_greyscale_image.ppm
Greyscale = (0.2126R) + (0.7152G) + (0.0722*B);
08_zero_gb_image.ppm
R = 0;
08_r_zero_b_image.ppm
G = 0;
08_rg_zero_image.ppm
B = 0;
08_grb_image.ppm
RGB => GRB
08_bgr_image.ppm
RGB => BGR
08_rrb_image.ppm
RGB => RRB
08_blended_two_images.ppm
Or blend two images together as above (based on bg: 06_xor_texture.ppm and fg: 04_helloworld_-
square.ppm). Or as below, with bg: 05_randomwalker.ppm and fg: 04_helloworld.ppm.
08_blended_two_images(2).ppm
But, now, let’s draw some lines.

This program is designed to generate two images: one with random lines and another with a damped
sine wave. The program includes various utility functions that handle operations like line drawing,
color conversion, line clipping, and saving images.
The ‘main’ function initializes the image as a vector of tuples, each representing a pixel color in
the form of RGB values. It first generates random lines by picking random points and colors, then
checks if the line is within the image’s dimensions using line clipping. If the line passes the clipping
check, it is drawn on the image. The resulting image, containing 15,000 random lines, is saved as
“09_random_lines.ppm”.
Next, the program creates an image of a damped sine wave. The image is initialized with a clear
background and a red line in the middle. The sine wave is drawn with a black color, and its damping
factor is represented with a grey color. The damped sine wave image is saved as “09_damped_-
sine.ppm”.
To achieve these functionalities, the program utilizes functions like ‘get_index’ and ‘calc_size’ to
handle image indexing and size calculations, ‘clear_image’ to set the image background to white,
and ‘h_to_rgb’ to convert hue values to RGB. Additionally, the program uses ‘draw_line’ to draw
lines on the image, ‘find_region’ and ‘clip_line’ to handle line clipping, and ‘save_image’ to save
the generated images to a file in PPM format.
Bresenham’s line algorithm, used in the ‘draw_line’ function, is an efficient and widely-used
technique for drawing lines on a raster grid, such as a computer screen or a digital image. Developed
by Jack E. Bresenham in 1962, the algorithm is notable for its simplicity, speed, and ability to produce
accurate line drawings using only integer arithmetic. It works by plotting a series of points between
two given endpoints, taking into account the discrete nature of raster grids and minimizing the error
between the ideal line and the plotted points.
The algorithm begins by calculating the differences in the x and y coordinates of the two endpoints,
and then determining the absolute values of these differences to establish the overall slope of the
line. Based on the slope, the algorithm chooses whether to increment the x or y coordinate at each
step, depending on which produces the least error. It does so by maintaining an error variable that
accumulates the difference between the ideal line and the plotted points. This error variable is used
to decide when to increment the other coordinate to keep the line as close to the ideal line as possible.
Bresenham’s line algorithm is particularly well-suited for computer graphics because it avoids the
use of floating-point arithmetic and division, which can be computationally expensive. Instead, it
relies on integer operations, which are generally faster and more efficient. This makes the algorithm
ideal for use in low-level graphics systems, such as early computer displays and video game consoles,
where computational resources are limited.
The ‘find_region’ and ‘clip_line’ functions uses the Cohen-Sutherland line clipping algorithm. This
algorithm is used to determine the parts of a line segment that lie within a rectangular viewport or
window. The main goal of the algorithm is to reduce the amount of line drawing computation
required for lines that are partially or entirely outside the viewport.
The Cohen-Sutherland algorithm assigns a 4-bit region code to each endpoint of a line segment
based on its position relative to the viewport. The bits correspond to the top, bottom, right, and
left regions outside the viewport. The ‘find_region’ function computes this region code for a given
point. If both endpoints have a region code of 0, the line segment is entirely inside the viewport, and
no clipping is required. If the bitwise AND of the two region codes is non-zero, the line segment is
entirely outside the viewport and can be discarded.
When a line segment straddles the viewport boundary, the ‘clip_line’ function comes into play.
This function iteratively clips the line segment against each edge of the viewport by calculating the
intersection point between the line and the edge. It then replaces the endpoint that lies outside the
viewport with the intersection point and updates its region code. This process is repeated until the
line segment is either fully inside the viewport or determined to be outside the viewport.
For the source code, take a look in Appendix A: 09_lines.cpp
09_random_lines.ppm
In this example we use HSV (Hue, Saturation, and Value) as a color model and converts it back to
RGB afterwords. A random Hue gets produced and with the h_to_rgb(float h) function we get a
RGB value back.
We also use clip_line function together with find_region function for clipping every line that is
clipped between the visible and non-visible screen.
‘std::mt19937’ is a C++ standard library implementation of the Mersenne Twister pseudorandom
number generator (PRNG) algorithm. The name “mt19937” is derived from the fact that the
Mersenne Twister uses a Mersenne prime number, 2^19937 - 1, as the basis for its internal state.
This PRNG is widely used for its high-quality random number generation, large period, and efficient
performance. Mersenne Twister is a popular choice for various applications, including simulations,
statistical modeling, and computer games, where high-quality random numbers are needed.
The ‘std::mt19937’ generator is part of the C++11 ‘’’ library is designed to offer a more versatile and
flexible approach to random number generation compared to older C++ functions like ‘rand()’ and
‘srand()’.
To use ‘std::mt19937’, you first need to create an instance of the generator and seed it with an initial
value. The quality of the random numbers generated depends on the seed value, which is typically
derived from a high-resolution clock or other sources of entropy. Once the generator is seeded, you
can use it to generate random numbers within a specified range or to generate random numbers
according to a probability distribution using distribution classes provided by the ‘’’ header.
09_damped_sine.ppm
Here we use the previous X and Y to draw a continous line that gets shaped into the demped sine
as calculated.
A damped sine wave is a sinusoidal function that gradually decreases in amplitude over time due to
the presence of a damping factor. In mathematical terms, a damped sine wave can be represented
as A(t) = A₀ * sin(ωt + φ) * e^(-αt), where A₀ is the initial amplitude, ω is the angular frequency, φ
is the phase, α is the damping factor, and t represents time. The damping factor, α, determines the
rate at which the amplitude decreases; a larger damping factor results in a more rapid decrease in
amplitude, while a smaller damping factor causes the amplitude to decay more slowly.
Damped sine waves can be effectively used in animations to create natural-looking motion or to
simulate physical processes that involve oscillatory behavior. For example, they can be employed to
animate the movement of a pendulum, the bouncing of a ball, or the oscillation of a spring. In these
cases, the damped sine wave helps to model the gradual loss of energy due to friction, air resistance,
or other dissipative forces that are present in real-world systems. By incorporating damped sine
waves into animations, designers can create more realistic and visually appealing motion that closely
mimics the behavior observed in nature, making the animation more immersive and engaging for
the audience.
Also, we can draw a line with starting x and y point, length and degrees.
09_angle_lines.ppm
The code is designed to create an image with lines drawn at different angles. The code begins
with several include statements, bringing in necessary libraries, followed by a series of function
definitions.
The ‘get_index’, ‘calc_size’, and ‘clear_image’ functions are utility functions for image manipula-
tion. ‘get_index’ calculates a one-dimensional index from two-dimensional coordinates, ‘calc_size’
calculates the total size of the image given its width and height, and ‘clear_image’ sets all pixels in
the image to white.
‘draw_line’ is a function that draws a line between two points in the image with a specified color.
The ‘find_region’, ‘clip_line’, and ‘get_angle_line’ functions are used for line clipping and angle
calculations. ‘find_region’ determines which region of the image a point lies in, ‘clip_line’ clips a
line to the image boundaries, and ‘get_angle_line’ calculates the endpoint of a line given a starting
point, angle, and length.
Finally, ‘save_image’ is a function that writes the image data to a file in PPM format.
The ‘main’ function initializes the image and sets its dimensions. It then draws lines at various
angles (0, 45, 90, 135, 180, 225, 270, and 315 degrees) around the center of the image with a fixed
length. The clip_line function is used to ensure that lines are only drawn within the boundaries of
the image. After drawing all the lines, the image is saved to a file named “09_angle_lines.ppm”.
5 There are no straight curves, only
curved lines
Bézier curve is a parametric curve. There are three types of Bézier curves:
• Linear Bézier curves

• Quadratic Bézier curves
• Cubic Bézier curves
Linear Interpolation, is a mathematical function that returns a value between two others at a point
on a linear scale. Most commonly it’s used for moving or changing values over a period of time.
With std::lerp (Linear Interpolation) function in C++20 we can draw curves using Linear, Quadratic
and Cubic Bézier curves (using a std::lerp inception; As they build on each other).
Reference: https://en.cppreference.com/w/cpp/numeric/lerp
C++17 version: https://github.com/emsr/cxx_linear
Use the lerp and midpoint code above if you’re only allowed to use C++17.
The C++ code demonstrates how to draw linear, quadratic, and cubic Bezier curves using dots on
an image. It creates an image with various types of Bezier curves and saves the result as a PPM
file. The code starts by including the necessary header files and then defines several functions to
compute the points on the Bezier curves, manipulate the image, and render the curves on the image.
The linear, quadratic, and cubic Bezier curve functions take the coordinates of the start, control, and
end points, along with the number of splits as input, and compute the points on the curves. Utility
functions are defined to help with image manipulation and rendering, such as getting an index in
the image vector, calculating the size of the image, clearing the image, and drawing lines.
In addition to the Bezier curve functions, the code also has functions to draw the Bezier curve points
and markers on the image, which are used for better visualization. Another function, save_image,
is defined to save the image as a PPM file.
In the main function, the program initializes the width and height of the image, creates a vector
for storing the image data, and then clears the image. Next, it draws linear, quadratic, and cubic
Bezier curves by using the previously defined functions. The program also draws the control lines
and markers for better visualization. Finally, it saves the resulting image as a PPM file named
“10_curved_dots.ppm”.
For the source code, take a look in Appendix A: 10_curved_dots.cpp
5 There are no straight curves, only curved lines 20
10_curved_dots.ppm
This is what std::lerp does… it’s these points that then can use a line function and dra the curve. The
curve is controlled with the two control points.
This C++ code is designed to create an image of curved lines using linear, quadratic, and cubic Bezier
curves. It first includes the necessary libraries and then defines several functions to calculate Bezier
curves, draw lines and dots, and save the image.
The ‘linear_bezier_curves’, ‘quadratic_bezier_curves’, and ‘cubic_bezier_curves’ functions are
used to generate the points for linear, quadratic, and cubic Bezier curves, respectively. The ‘draw_-
line’ function draws a straight line between two points. The ‘draw_xy_line’ function draws a line
using the points generated from Bezier curves, while the ‘draw_xy_dots’ function draws dots at
the points generated by the Bezier curves.
The ‘draw_marker’ function creates a small marker at a specified point, and the ‘save_image’
function saves the image to a file in PPM format.
In the ‘main’ function, the code sets up an image of specified width and height and fills it with a
white background. Then, it proceeds to draw lines using the Bezier curves functions, along with
markers and dots at various points. Finally, it saves the created image to a file.
The code demonstrates the use of linear, quadratic, and cubic Bezier curves to create smooth curves
between points in an image, as well as drawing markers and dots at specific points along the curve.
For the source code, take a look in Appendix A: 10_curved_lines.cpp
10_curved_lines.ppm
Here we have the curves drawn with the line function and the points is marked as well as also the
control points.
6 Rectangles with Standard Library
A rectangle is a closed 2D shape, having 4 sides, 4 corners, and 4 right angles (90°).The opposite
sides of a rectangle are equal and parallel. Since, a rectangle is a 2D shape, it is characterized by
two dimensions, width, and height. To draw a rectangle you’ll need X and Y together with the
rectangles width and height.
The C++ code generates an image containing two rectangles, one outlined and one filled, saved as a
PPM file. The code consists of several functions, each serving a specific purpose in order to create
and manipulate the image.
The first few functions in the code are used for basic image handling. The ‘get_index’ function
calculates the index of a pixel in a 1D vector representation of a 2D image given its (x, y) coordinates
and the image width. The ‘calc_size’ function calculates the size of the image given its width and
height, while the ‘clear_image’ function fills the image vector with white pixels (R=1.0, G=1.0,
B=1.0).
Next, there are functions for drawing shapes on the image. The ‘draw_line’ function draws a line
between two points in the image using Bresenham’s line algorithm, an efficient method for drawing
lines on a raster grid. The ‘draw_rect’ function draws an outlined rectangle by connecting its four
corners using the ‘draw_line’ function. The ‘draw_filled_rect’ function, on the other hand, draws
a filled rectangle by iterating over its area and setting the color of each pixel inside the rectangle.
Finally, the ‘save_image’ function saves the image to a PPM file, which is a simple, uncompressed
image file format.
In the ‘main’ function, the image parameters, such as width, height, and the position and size of the
two rectangles are initialized. Then, a vector representing the image is created and initialized with
white pixels. After that, the two rectangles are drawn on the image. The resulting image is then
saved to a PPM file named “11_rectangles.ppm”.
For the source code, take a look in Appendix A: 11_rectangles.cpp
11_rectangles.ppm
Here we have a rectangle and a filled rectangle.

The code reads a series of rectangle specifications from a file, and then generates an image containing
those rectangles, with a background color and overlapping filled rectangles. The primary purpose
6 Rectangles with Standard Library 22
of the code is to create an image where the filled rectangles are blended with the background color
using an alpha channel for transparency.
The code starts by including necessary headers and defining helper functions such as ‘startsWith-
CaseInsensitive’, ‘get_index’, ‘calc_size’, ‘clear_image’, ‘parse_bginfo_line’, ‘parse_rect_line’,
‘blend_colors’, ‘draw_filled_rect’, and ‘save_image’. These functions perform various operations,
such as string manipulation, parsing input lines, calculating indices for a 2D image stored as a 1D
vector, blending colors, drawing rectangles, and saving the final image as a PPM file.
In the ‘main’ function, the program reads lines from the input file “11_squint_with_your_eyes.txt”.
If a line starts with “r”, it is considered a rectangle specification and parsed using the parse_rect_line
function. The rectangle’s coordinates, color, and alpha values are then used to draw the rectangle
on the image using the ‘draw_filled_rect’ function. If a line starts with “b”, it is considered a
background specification and parsed using the ‘parse_bginfo_line’ function. The background color
and image dimensions are extracted from the line, and the image vector is resized accordingly. The
‘clear_image’ function is called to fill the entire image with the background color.
After processing all the lines from the input file, the program saves the resulting image to a PPM
file called “11_squint_with_your_eyes.ppm” using the ‘save_image’ function. The PPM file format
is a simple, text-based format that stores pixel color information as plain text. The code writes the
PPM header, followed by the pixel color values, one pixel per line, in the output file.
For the source code, take a look in Appendix A: 11_rectangles_from_file.cpp
For the source code, take a look in Appendix A: 11_squint_with_your_eyes.txt
11_squint_with_your_eyes.ppm
This is an example how you can read data and present it into a image.
7 Circles with Standard Library
A circle is a round-shaped figure that has no corners or edges.
The midpoint circle algorithm is a widely-used technique for efficiently drawing circles on raster
displays, such as computer screens or images. The algorithm was developed as an extension of
Bresenham’s line algorithm, which is used for drawing lines. The midpoint circle algorithm employs
integer arithmetic and incremental calculations to minimize computational overhead and avoid
the use of computationally expensive floating-point arithmetic, such as square root operations. It
generates a set of points on the circle’s circumference, taking advantage of the circle’s inherent
symmetry to reduce the number of calculations required.
The algorithm works by starting at the topmost point of the circle and incrementally moving towards
the x-axis while calculating the appropriate y-coordinate for each x-coordinate. It does this by
evaluating a decision parameter at each step to determine whether to increment the x-coordinate,
the y-coordinate, or both. The decision parameter is based on the circle equation, and it helps to
determine whether the midpoint between two candidate pixels is inside or outside the circle. If the
midpoint is inside the circle, the algorithm chooses the pixel closer to the x-axis; if it is outside, the
algorithm chooses the pixel closer to the y-axis.
One of the key features of the midpoint circle algorithm is its ability to exploit the eightfold
symmetry of a circle. Since a circle is symmetrical about both the x and y axes, as well as the
lines y = x and y = -x, the algorithm only needs to compute the points in one-eighth of the
circle and then derive the remaining points by reflection. This significantly reduces the number
of calculations required to draw the entire circle. The result is an efficient method for drawing
circles in computer graphics, particularly when working with low-level raster graphics operations
or limited computational resources.
This C++ code generates an image containing two circles, one filled and one unfilled, with a white
background. The primary purpose of the code is to demonstrate the process of drawing circles using
a simple implementation of the midpoint circle algorithm and saving the resulting image as a PPM
file.
The code starts by including necessary headers and defining helper functions, such as ‘get_index’,
‘calc_size’, ‘clear_image’,‘draw_circle’, ‘draw_filled_circle’, and ‘save_image’. These functions
perform various operations, such as calculating indices for a 2D image stored as a 1D vector, clearing
the image by setting all pixel colors to white, drawing unfilled and filled circles using the midpoint
circle algorithm, and saving the final image as a PPM file.
In the ‘main’ function, the program sets the width and height of the image, as well as the positions
and radii of the two circles. The x and y coordinates, as well as the radius of the circles, are calculated
based on the dimensions of the image. The image vector is resized accordingly, and the ‘clear_image’
function is called to fill the entire image with the white background color.
7 Circles with Standard Library 24
Next, the ‘draw_circle’ function is called to draw the first circle (unfilled) on the image, and the
‘draw_filled_circle’ function is called to draw the second circle (filled) on the image. Both functions
use the midpoint circle algorithm to determine which pixels to set to the desired color (black in
this case). The ‘draw_filled_circle’ function additionally fills the interior of the circle by drawing
horizontal lines between the boundary points.
Finally, the ‘save_image’ function is called to save the resulting image as a PPM file called “12_-
circle.ppm”. The PPM file format is a simple, text-based format that stores pixel color information
as plain text. The code writes the PPM header, followed by the pixel color values, one pixel per line,
in the output file.
For the source code, take a look in Appendix A: 12_circle.cpp
12_circle.ppm
Here we have a circle and a filled circle.

A program that reads circle specifications from a text file and generates a Portable Pixmap (PPM) file
containing an image of the circles. The code starts by including necessary libraries, such as those for
file streams, tuples, vectors, and mathematical functions. Then, several utility functions are defined
to perform tasks like case-insensitive string matching, index calculations, image size determination,
and image clearing.
The program then includes functions for parsing the circle and background information from the
input file. These functions, ‘parse_circle_line’ and ‘parse_bginfo_line’, process each line of the
input file and extract the relevant information. For circle specifications, it extracts the coordinates,
radius, and color information, while for background information, it extracts the image dimensions
and color.
Next, the code defines several functions to handle color blending, region finding, and line clipping.
The ‘blend_colors’ function combines two colors based on their transparency, while ‘find_region’
and ‘clip_line’ deal with determining which portions of the circle are visible within the image
boundaries.
The main functionality of the program is found in the ‘draw_filled_circle’ function, which takes
the circle’s center coordinates, radius, color, and image dimensions as arguments. It uses an efficient
algorithm to draw filled circles, updating the image buffer with the circle’s color. The ‘save_image’
function saves the generated image to a PPM file.
Finally, the ‘main’ function reads the input file and calls the appropriate functions to parse the circle
and background information. It initializes an empty image and fills it with the background color,
then iterates through each circle specification and draws the circle onto the image. Once all circles
have been drawn, it saves the image to a file and exits.
For the source code, take a look in Appendix A: 12_circles_from_file.cpp

Another example of reading data and rendering an image.

Let’s draw a wedge using arc.
The algorithm used to draw the wedge in the program is a combination of trigonometry and the
Bresenham’s line algorithm. The trigonometric aspect calculates the points along the arc of the
wedge, while Bresenham’s line algorithm is used to draw the straight lines that form the sides of the
wedge.
To calculate the points along the arc, the algorithm begins by converting the starting and ending
angles to radians. Then, it iteratively computes the x and y coordinates using the cosine and sine
functions of the current angle, and adds them to a list of coordinates. The iteration continues with
a small increment in the angle until the ending angle is reached.
For the straight sides of the wedge, Bresenham’s line algorithm is used to connect the center of the
circle to the start and end points of the arc. Bresenham’s line algorithm is a widely used technique
for drawing lines in computer graphics, as it efficiently calculates the integer points along the line
without using floating-point arithmetic. The algorithm iteratively updates the x and y coordinates
while minimizing the error between the actual line and the drawn points. The combination of the
arc points and the lines generated by Bresenham’s algorithm creates the complete wedge shape.
12_wedge.ppm
This C++ program generates an image with a radial pattern resembling a wedge or a pie slice. The
image is saved in the PPM format.
The program begins by including necessary headers and defining functions for handling image data,
such as calculating the size of the image, clearing it, and saving it to a file. It also contains functions
to draw lines and wedges, both filled and unfilled, on the image. The main part of the program
initializes the image dimensions and creates an empty white image of the specified size.
The program then sets the center, radius, and angles for the wedge to be drawn. The center of the
wedge is set to be the midpoint of the image, and the radius is set to 80% of half of the image height.
The starting and ending angles of the wedge are defined in degrees, with 0 and 348 degrees being
used in this example.
Next, the program draws a filled black wedge with the specified dimensions, followed by a filled gray
wedge with half the radius, creating a “doughnut” shape. Then, it draws an unfilled purple wedge
outline around the larger black wedge. Finally, the image is saved to a file named “12_wedge.ppm”.
For the source code, take a look in Appendix A: 12_wedge.cpp
8 Triangles with Standard Library
A triangle is a closed, 2 dimensional shape with 3 sides, 3 angles, and 3 vertices. A triangle is also a
polygon.
Create an image containing two triangles, one outlined and the other filled, and save it as a PPM
file. The code is divided into several sections, such as defining functions for operations on images,
drawing lines and triangles, and the main program logic.
The program begins by including necessary headers and then defining several utility functions.
The ‘get_index’ function calculates the index of a given pixel in a 1D vector based on its x and
y coordinates and the image width. The ‘calc_size’ function calculates the total number of pixels
in an image given its width and height. The ‘clear_image’ function sets all pixels in an image to a
specified color.
The ‘draw_line’ function uses a modified Bresenham’s line algorithm to draw a line between two
points on an image. The ‘draw_triangle’ and ‘draw_filled_triangle’ functions utilize the ‘draw_-
line’ function to draw the edges of triangles, either outlined or filled, using an incremental scanline
rendering approach.
The ‘save_image’ function takes an image represented as a vector of RGB color tuples, its width
and height, and a filename as arguments, and saves the image as a PPM file.
In the main function, the program first initializes the width and height of the image, as well as the
coordinates of the vertices of the two triangles. It then creates a vector to store the image and sets
its initial color to white using the ‘clear_image’ function. Next, it sets the color to black and calls
the ‘draw_triangle’ function to draw the first triangle and the ‘draw_filled_triangle’ function to
draw the second triangle.
Finally, the program saves the image using the ‘save_image’ function, resulting in a PPM file
containing the two triangles.
For the source code, take a look in Appendix A: 13_triangles.cpp
13_triangles.ppm
Here we have a triangle and a filled triangled

This C++ code reads a file containing information about triangles and their colors, then generates a
raster image of the triangles. The program starts by including necessary headers, such as iostream,
8 Triangles with Standard Library 28
fstream, tuple, vector, random, cmath, and algorithm. It defines several utility functions to handle
string processing, coordinate calculations, and image manipulation. The main part of the code
consists of functions to parse input strings, blend colors, find the region of a point, clip lines, draw
filled triangles, and save the generated image to a file.
The ‘parse_bginfo_line()’ and ‘parse_triangle_line()’ functions read lines from the input file
and convert the data into the appropriate data types for further processing. The ‘blend_colors()’
function is used to blend colors using the alpha value, which determines how transparent the color
should be when applied to the image. The ‘find_region()’ and ‘clip_line()’ functions are used to
determine if a point is within the image bounds and to clip any lines that are outside of the image
bounds, respectively.
The ‘draw_filled_triangle()’ function is responsible for rendering triangles onto the image. It uses
a scanline algorithm to fill the triangles with the specified color. This function takes care of edge
cases and ensures that the triangles are drawn correctly within the image boundaries. Finally, the
‘save_image()’ function writes the generated image data to a file in PPM (Portable Pixmap) format.
For the source code, take a look in Appendix A: 13_triangles_from_file.cpp
Another example.
9 Animation with Standard Library
Below is four example of animation you can do… of course the animation might be more releated
to graphs then images.
You can animate shapes, color transition, opacity and movment.
A C++ program that creates a simple animation using a random walker algorithm. It reads an image
file in PPM format, generates a sequence of images, and saves them in a specified directory. The
user can then use a tool like FFmpeg to convert the image sequence into a video format.
The program begins by defining several helper functions for tasks such as reading and writing
PPM images, updating the positions of the walkers, and blending two images together. The ‘main’
function reads an image from a file, creates a second image buffer, and then initializes the walker
positions to the center of the image. It then iterates over a loop for a large number of steps, moving
the walkers randomly in one of the four cardinal directions and updating the image buffer with the
color from the first image at the new walker positions.
After every 100 steps, the program saves the current state of the image buffer as a new PPM file.
The animation created by this program consists of two walkers moving randomly over the image,
revealing its contents as they traverse it.
For the source code, take a look in Appendix A: 14_animation05.cpp
An animation program that generates a series of images based on input data from a text file. The
text file contains information about the background and rectangles to be drawn on the images.
The program begins by including necessary libraries and defining functions that will be used
later on. Functions include ‘startsWithCaseInsensitive’ for checking if a string starts with a
specific substring, ‘get_index’ and ‘calc_size’ for converting 2D coordinates into 1D indices, and
‘clear_image’ for initializing an image with a specified background color.
The program also contains functions for parsing the input text file, such as ‘parse_bginfo_line’
and ‘parse_rect_line’, which extract relevant information from the input lines. Another important
function is ‘blend_colors’, which combines two colors based on their alpha values. The ‘draw_-
filled_rect’ function is responsible for drawing filled rectangles on the image using the ‘blend_-
colors’ function. The ‘get_filname’ function generates a filename for the output image, and the
‘save_image’ function saves the image to a file.
The ‘main’ function of the program begins by creating an output directory and opening the input
text file. The program then iterates through each line of the text file, checking if the line starts
with ‘r’ for rectangle or ‘b’ for background. If it starts with ‘r’, the program parses the rectangle
information, draws the rectangle on the image, and saves the image. If the line starts with ‘b’, the
program parses the background information, resizes the image, sets the background color, and saves
9 Animation with Standard Library 30
the image. The program prints the filenames of the saved images to the console and closes the input
file at the end.
Works the same as 14_animation11.cpp. Uses cricles instead of rectangles.
Works the same as 14_animation11.cpp. Uses triangles instead of rectangles.
Just experiment and use what you think looks good.
10 Drawing Charts and a Font
The flood-fill algorithm is a popular technique in computer graphics and image processing for filling
an area with a specified color. This algorithm works by starting at a seed pixel and recursively or
iteratively filling neighboring pixels that share the same color as the seed pixel, ultimately replacing
them with a new target color. The process continues until all the connected pixels sharing the
original color are filled with the new color. The flood-fill algorithm has several variations, such as
4-way and 8-way connectivity, which determine how pixels are considered neighbors based on their
relative positions.
Flood-fill algorithms have various applications, particularly in image editing software, computer
games, and pattern recognition tasks. In image editing software, the flood-fill tool, commonly
known as the paint bucket, is used to fill areas with a uniform color or pattern. This tool allows
users to easily modify images by changing the color of specific regions or creating new shapes. In
computer games, the flood-fill algorithm can be employed for tasks like procedural map generation,
pathfinding, or detecting connected components in a game world. In pattern recognition, flood-fill
algorithms can be used to identify and isolate distinct regions or objects within an image based on
their color or texture properties.
Despite its popularity and numerous applications, the flood-fill algorithm does have some limita-
tions. Its performance can be affected by the size of the area to be filled and the complexity of the
image. Recursive implementations of the flood-fill algorithm are prone to stack overflows when
dealing with large areas, while iterative implementations can be memory-intensive. Additionally,
the algorithm may fail to provide the desired output if there are gaps or holes in the boundaries of
the region to be filled. In such cases, modifications to the algorithm, like tolerance-based flood-fill
techniques, can be applied to address these issues and achieve more accurate results.
A program that demonstrates the creation and manipulation of a radar chart, which is a graphical
representation of multivariate data in the form of a two-dimensional chart. This code can be
compiled using the command provided at the beginning of the code.
The program begins by including the required header files and defining a set of functions to
manipulate images, such as calculating the index, clearing the image, drawing shapes, and clipping
lines. Some functions, like ‘get_index’ and ‘calc_size’, are utility functions that help with image
manipulation, while others, like ‘draw_circle’ and ‘draw_filled_circle’, are responsible for drawing
specific shapes on the image.
The ‘floodfill_algorithm’ function is an implementation of the flood-fill algorithm that fills an
enclosed area of an image with a specified color. The ‘get_all_ys’ and ‘draw_line_coords’ functions
are used for drawing polygons on the image. The ‘draw_polygon’ and ‘draw_filled_polygon’
functions use these helper functions to draw and fill polygons, respectively.
10 Drawing Charts and a Font 32
The ‘draw_line’ function takes an image, a set of coordinates, a color, and the width and height of
the image, and draws a line on the image using the given coordinates and color. The ‘find_region’
and ‘clip_line’ functions are used to clip lines based on the width and height of the image, ensuring
that lines do not extend beyond the boundaries of the image.
For the source code, take a look in Appendix A: 15_radarchart.cpp
15_radarchart.ppm
As 15_radarchart.ppm width is 1920 pixels and height is 1080, the size of the PPM is getting a bit big
to write as a textfile. That is why save_image()-function saves the PPM as a P6 with the RGB as 3
byte binary data.
This code is written in C++ and is used to generate a radial chart with three colored segments
representing three different categories of data. The chart consists of 52 wedges, each representing a
week. The data for each category is provided in three arrays ‘a1’, ‘a2’, and ‘a3’. The chart is then
saved as an image in PPM (Portable Pixmap) format.
The program begins by including the necessary header files and defining some utility functions for
working with images, such as ‘get_index’, ‘calc_size’, ‘clear_image’, and others. These functions
are used for creating and manipulating the image data structure, a vector of tuples representing
RGB colors. Functions like ‘draw_filled_circle’, ‘draw_filled_wedge’, and ‘save_image’ are used
to draw and save the final image.
The ‘main’ function starts by initializing the image data structure and setting up color tuples
for the background and three data categories. It calculates the center of the image, the radius,
and other necessary parameters for drawing the radial chart. It then draws a filled circle with a
specific background color and iterates through the 52 wedges, drawing filled wedges for each of
the three categories using the data provided in ‘a1’, ‘a2’, and ‘a3’. The wedges are drawn using
the ‘draw_filled_wedge’ function, which in turn uses the ‘draw_line_coords’ function to create
line coordinates for the wedges. After drawing all the wedges, the image is saved to a file named
“15_weekchart.ppm” using the ‘save_image’ function.
For the source code, take a look in Appendix A: 15_weekchart.cpp
15_weekchart.ppm
Also as a P6 PPM as it has the same width and height as 15_radarchart.ppm.

This C++ code reads and writes P6 PPM (Portable PixMap) image files. The main purpose is to load
an image file, and then save it to another file without any modification. The code is organized in
three main sections: the ‘load_image’ function, the ‘save_image’ function, and the ‘main’ function.
The ‘load_image’ function takes a reference to a vector of tuples of floats, width and height integers,
and a string for the filename. It opens the file in binary mode, reads the magic number (which should
be “P6”), skips any comments, reads the image dimensions and maximum color value, and then reads
the pixel data into the vector of tuples. The pixel data is normalized by dividing the individual color
values by 255.0, which makes it easier to work with in future operations.
The ‘save_image’ function is responsible for writing an image back to a file. It takes the same
arguments as the ‘load_image’ function, but instead of reading the data, it writes the image data to
a file. It writes the magic number, image dimensions, and maximum color value, and then writes
the pixel data, converting the normalized float values back to the 0-255 range.
The ‘main’ function starts by defining a vector of tuples to store the image data and integer variables
for width and height. It then calls the ‘load_image’ function to read the image file, prints out the
width and height of the image, and finally calls the ‘save_image’ function to save the image data
to a new file.
This code can be used as a starting point for more complex image manipulation tasks, as it provides
a simple way to read and write PPM files.
To read a P6 PPM, take a look in Appendix A: 15_read_p6_ppm.cpp
Let’s create a font and render all the letters in it.
This code generates images of hand-drawn styled letters and numbers. The program defines a set of
functions to draw each character, using the Bresenham’s line algorithm to get the points of the lines
that make up the characters. It also defines functions to draw filled circles, clear the image, and save
the image in the PPM (Portable Pixmap) format.
The main function (draw_and_save_font) iterates through each character, draws it with the specified
color, width, height, margin, and line size, and saves the resulting image to a PPM file.
Each draw_font_ function has two main components:
• An array of points that define the character’s shape, where the points are represented by their
relative X and Y coordinates.
• An array of line segments that connect these points, where each line segment is represented
by a pair of indices corresponding to the points array.
In each function, the code iterates through the line segments, calculates the coordinates of the actual
points on the image canvas by scaling and translating the relative coordinates, and adds the points
to the points vector.
The draw function takes the points vector and the other parameters, and updates the image by either
drawing a single pixel (when the line size is 1) or drawing a filled circle centered at each point.
Finally, the save_image function writes the image data to a PPM file, using the specified filename.
Here’s a brief explanation of the purpose of each function:
• draw_font_: Draws the specified character by adding its line points to the points vector.
• get_line_points: Uses Bresenham’s line algorithm to get the points of a line segment.
• draw_filled_circle: Draws a filled circle centered at the specified point with the specified
radius.
• clear_image: Resets the image to a white background.
• save_image: Saves the image to a PPM file with the specified filename.
• draw: Updates the image with the specified points, color, line size, etc.
• draw_and_save_font: Main function that iterates through each character, draws it, and saves
the image to a file.
To draw each letter in the font, take a look in Appendix A: 15_draw_font.cpp

11 Presentation, Collaboration, and
Investigation
11.1 Presentation
Creating charts and diagrams can be a great way to visualize data and communicate information.
This chapter will show you how to create 2D charts and diagrams using C++.
We’ll start by showing you how to create basic shapes and lines. Then we’ll make more complex
shapes like circles and rectangles. Finally, we’ll show you how to add text and labels to your charts
and diagrams.
By the end of this chapter, you’ll know how to create professional-looking 2D charts and diagrams
using C++. So let’s get started!
11.2 Draw a bar chart

Draw a bar chart by just hacking away.
This generates an image of a bar chart with specific characteristics. The chart has 5 bars and 4 icons
drawn in the image, as well as percentage values. The code is structured in various functions that
are called in the ‘main’ function to build and save the image.
The program starts with the necessary includes, such as iostream, fstream, tuple, vector, random,
and cmath. The ‘get_index’ function calculates an index for accessing elements of the image vector.
The ‘calc_size’ function calculates the size of the image based on the width, height, and margin.
The ‘clear_image’ function initializes the image with a specific color (a shade of gray).
The ‘draw_filled_rect’ function takes the position (x, y), dimensions (w, h), image reference, color,
width, and height as parameters and draws a filled rectangle on the image. The ‘draw_line’ function
takes the image reference, a tuple of coordinates, color, width, and height as parameters and draws a
line on the image. The ‘save_image’ function takes the image reference, width, height, and filename,
and saves the image as a PPM file.
In the ‘main’ function, the program initializes the image, fills it with the background color, and
then draws the bar chart by calling ‘draw_filled_rect’ and ‘draw_line’ functions with specific
parameters. The bars, icons, and percentages are drawn using these functions. After drawing the
chart, the image is saved to a file with a specified filename.
11 Presentation, Collaboration, and Investigation 37
16_draw_bar_chart.ppm
Drawing a bar chart, take a look in Appendix A: 16_draw_bar_chart.cpp
11.3 Draw a pie chart

The code is designed to create and output a simple pie chart. It first includes necessary headers
such as iostream, fstream, tuple, vector, random, cmath, and algorithm to handle various functions
required in the program. It then defines a set of functions for various calculations and operations.
The function ‘get_width_from_height’ calculates the width of the pie chart based on the height.
‘get_margin_from_height’ calculates the margin size for the chart based on the height. ‘get_index’
returns the index of a pixel in the image vector given its x and y coordinates and the width of the
image. The ‘calc_size’ function calculates the size of the chart based on its width, height, and
margin.
The ‘stamp’ function is responsible for stamping the image of a letter onto the pie chart, while
the ‘clear_image’ function sets the initial color of the pie chart to a light orange color. Functions
‘get_line_points’, ‘draw_font_M’, ‘draw_font_A’, ‘draw_font_R’, ‘draw_font_S’, ‘draw_font_-
V’, ‘draw_font_E’, ‘draw_font_N’, ‘draw_font_U’, and ‘draw_font_C’ handle drawing of the
individual letters on the pie chart using line segments and points. Each letter is represented by
a set of coordinates and lines connecting them.
16_draw_pie_chart.ppm
Pie chart in PPM, take a look in Appendix A: 16_draw_pie_chart.cpp
11.4 Draw a donut chart

The code provided is a C++ program that creates a donut chart with the letters “MARS” in the
center. It uses a variety of functions to draw lines, circles, and characters on a 2D grid, ultimately
constructing the desired image.
The program starts by including necessary headers and defining functions to perform operations
such as calculating width and margin based on height, calculating the index of a 2D point in a 1D
array, and clearing the image by setting a background color. Functions are also defined for drawing
lines between two points and drawing filled circles.
There are several functions dedicated to drawing individual characters like ‘M’, ‘A’, ‘R’, and ‘S’.
These functions first define an array of points representing the outline of each character and then
another array of lines connecting those points. Using the ‘get_line_points’ function, lines are drawn
between the specified points to create the shape of the characters.
The ‘draw_filled_circle’ function takes in the center coordinates of a circle, its radius, and a color,
and then fills the circle with that color. The ‘draw_filled_circle2’ function is a slightly modified
version of ‘draw_filled_circle’ without the margin parameter.
The ‘get_all_ys’ function collects all the y-coordinates from a set of coordinates, sorts them, and
removes duplicates. The ‘draw_line_coords’ function is a helper function for drawing lines between
two points and storing the resulting coordinates in a vector.
The ‘stamp’ function is used to place one image (letter) onto another image (donut chart) at a
specified offset. The ‘draw_filled_circle_segment’ function draws a filled segment of a circle, given
the start and end angles.
Finally, the ‘main’ function of the program sets up the dimensions and colors for the donut chart
and uses the functions defined earlier to draw the chart and letters. The resulting image is then
saved as a PPM file, which can be opened with an image viewer that supports the format.
16_draw_donut_chart.ppm
Pie chart in PPM, take a look in Appendix A: 16_draw_donut_chart.cpp
11.5 Draw a table

This C++ code is designed to draw a table, save the image as a PPM file, and demonstrate various
graphics functions such as drawing lines, circles, and rectangles. It includes various functions to
perform these tasks and a main function to tie them all together.
First, the necessary libraries are included at the beginning of the code. The ‘get_width_from_-
height’ function calculates the width of the table based on its height, while the ‘get_margin_from_-
height’ function calculates the margin based on the height. The ‘get_index’ function calculates the
index of a point in a one-dimensional vector based on its x and y coordinates and the given width.
The ‘calc_size’ function calculates the size of the image, taking into account the width, height, and
margin. The ‘clear_image’ function initializes the image vector by setting the color of each pixel to
a light brownish color. The ‘stamp’ function stamps the input image (i.e., the letters) onto another
image at a specified position.
The ‘get_line_points’ function calculates the points along a line using Bresenham’s line algorithm,
given the coordinates of the two endpoints and a color. This function is used in the ’draw_font*’_-
functions, where each function (e.g., ‘draw_font_M’, ‘draw_font_A’, etc.) is responsible for
drawing the respective letter using lines. Each of these functions sets up arrays containing the
coordinates of the points and lines that make up the letter, and then calls ‘get_line_points’ to
calculate the points along each line.
The ‘draw_filled_circle’ and ‘draw_filled_rect’ functions draw filled circles and rectangles,
respectively, on the image. The ‘save_image’ function saves the image as a PPM file, given the
image data, its dimensions, and the output filename.
The draw function is used to draw a set of points on the image. The points are drawn as filled
circles with a specified line size. Finally, the ‘main’ function initializes the image, sets the colors
and dimensions for the table, and calls the various drawing functions to create the image. It then
saves the image to a file named “table.ppm”.
16_draw_table.ppm
Pie chart in PPM, take a look in Appendix A: 16_draw_table.cpp.cpp
11.6 Draw a more advanced chart 1

The given function, ‘generate_noise_image’, is designed to create a noise image by generating
random grayscale pixel values. The noise image is represented as a vector of tuples, where each
tuple contains three float values representing the red, green, and blue channels of a pixel.
The function takes two parameters: a reference to an ‘std::vector’ of tuples named image which will
store the generated noise ‘image’, and two integers ‘width’ and ‘height’ representing the dimensions
of the desired noise image. The function begins by defining a tuple named ‘color’ and a float variable
named ‘rndnum’, which will be used to store random grayscale values.
Next, the function sets up a random number generator using the ‘std::random_device’ and
‘std::mt19937’ classes from the C++ standard library. The random number generator is configured
to produce float values uniformly distributed between 0.0 and 1.0.
The function then iterates through each pixel in the image, using two nested loops. The outer loop
iterates through the height of the image, while the inner loop iterates through the width. For each
pixel, a random number is generated using the previously configured random number generator,
and the ‘color’ tuple is set to contain the random number for all three channels (red, green, and
blue). This creates a grayscale color, as all channels have the same value. The ‘color’ tuple is then
assigned to the corresponding position in the ‘image’ vector using the ‘get_index’ function, which
converts 2D coordinates (x, y) into a 1D index suitable for accessing the vector.
By the end of the function, the ‘image’ vector will contain a representation of a noise image with
the specified width and height, where each pixel is a randomly generated grayscale value.
Step #1: 16_draw_market_size1.ppm
The ‘generate_linear_gradient_image’ function creates a linear gradient image by blending two

colors across the image vertically. The resulting image is represented as a vector of tuples, where
each tuple contains three float values representing the red, green, and blue channels of a pixel.
The function takes four parameters: a reference to an ‘std::vector’ of tuples named image which
will store the generated gradient ‘image’, two tuples named ‘fcolor’ and ‘tcolor’ representing the
starting and ending colors of the gradient, and two integers ‘width’ and ‘height’ representing the
dimensions of the desired gradient image. The function begins by defining a tuple named ‘color’
and double variables ‘resultRed’, ‘resultGreen’, and ‘resultBlue’ which will be used to store the
blended color values for each pixel.
Additionally, the function defines variables ‘fr’, ‘fg’, ‘fb’, ‘tr’, ‘tg’, and ‘tb’ for storing the individual
red, green, and blue components of the starting and ending colors. The ‘std::tie’ function is used to
unpack the ‘fcolor’ and ‘tcolor’ tuples into these separate variables.
The function then iterates through each row of the image using a loop that iterates through the
height of the image. For each row, the function calculates the percentage of the total height that the
current row represents. This percentage is then used to blend the starting and ending colors for that
row, by computing the weighted average of the respective color components (red, green, and blue).
The resulting blended color is stored in the ‘color’ tuple using the ‘std::make_tuple’ function.
Next, the function iterates through each column in the current row using a nested loop. For each
pixel in the row, the ‘color’ tuple containing the blended color for the current row is assigned to
the corresponding position in the ‘image’ vector using the ‘get_index’ function, which converts 2D
coordinates (x, y) into a 1D index suitable for accessing the vector.
By the end of the function, the ‘image’ vector will contain a representation of a linear gradient
image with the specified width and height, where the colors gradually blend from the starting color
at the top of the image to the ending color at the bottom.
‘blended_two_images’ blends two images together using a specified alpha value. It takes five input
parameters: two vectors of tuples representing the colors of the two images, the width and height
of the images, and a float value called alpha.
First, the function initializes three tuple variables ‘color1’, ‘color2’, and three float variables ‘r’,
‘g’, and ‘b’. The tuples represent colors from the first and second images, while the float variables
represent the blended color components - red, green, and blue.
The function then uses two nested loops to iterate over the width and height of the images. The
outer loop iterates over the height of the images, and the inner loop iterates over the width. Inside
the inner loop, the function extracts the colors at the current position ‘(x, y)’ from both images using
the ‘get_index’ function, which computes the index in the vector based on the x, y coordinates and
the width.
Next, the function calculates the blended color components (red, green, and blue) using the alpha
value. The blending operation is performed by multiplying each color component of the second
image by the alpha value and adding the product of the color component from the first image and
(1.0 - alpha). This is done for all three color components - red, green, and blue.
After calculating the blended color components, the function stores the blended color as a tuple in
the first vector at the same position ‘(x, y)’. This overwrites the original color in the first image with
the blended color. Once the loops have finished, the first vector will contain the resulting blended
image.
‘generate_radial_gradient_image’ generates a radial gradient image using two input colors. It

takes four input parameters: a vector of tuples representing the colors of the output image, two
tuples representing the colors to create the gradient (from-color and to-color), and the width and
height of the image.
First, the function initializes several variables: color for storing the current ‘color’ being com-
puted, ‘pink’ for a predefined color, ‘mask’ for a vector of tuples to store an intermediate mask,
‘distanceFromCenter’ for calculating the distance from the center of the image, and ‘resultRed’,
‘resultGreen’, and ‘resultBlue’ for storing the resulting color components.
The function starts with two nested loops to iterate over the width and height of the image. Inside
the inner loop, the function sets the initial values of the ‘mask’ and ‘image’ vectors at the current
position ‘(x, y)’ to the predefined ‘pink’ color and the ‘from-color’, respectively.
The function then initializes several variables for drawing a circle using Bresenham’s circle
algorithm. It declares a lambda function ‘drawline’ that is used to draw horizontal lines at the
specified positions. It loops over the circle, drawing lines for each quadrant, and updates the mask
vector accordingly.
After completing the circle drawing, the function starts another pair of nested loops to iterate over
the width and height of the image once more. Inside the inner loop, the function checks if the current
position ‘(x, y)’ in the ‘mask’ vector is not equal to the predefined ‘pink’ color. If this condition
is true, it calculates the distance from the center of the image and computes the resulting color
components based on the distance and the input ‘from-color’ and ‘to-color’. The function then
assigns the computed color to the ‘image’ vector at the current position ‘(x, y)’.
If the condition is false, meaning that the ‘mask’ vector has the ‘pink’ color at the current position
‘(x, y)’, the function assigns the ‘to-color’ to the ‘image’ vector at the current position. This way,
the final image vector will contain a radial gradient image generated using the input colors.
‘generate_repeating_texture_image’ generates a repeating texture image using an input color. The

function takes three input parameters: a vector of tuples representing the colors of the output image,
a tuple representing the color to create the texture, and the width and height of the image.
First, the function initializes a tuple called ‘bgcolor’ to store a predefined background color. Then,
it uses two nested loops to iterate over the width and height of the image. Inside the inner loop, the
function sets the initial value of the ‘image’ vector at the current position ‘(x, y)’’ to the background
color.
Next, the function defines two arrays named ‘arr’ and ‘arr2’, which store the coordinates and indices
of the line segments to draw the repeating texture pattern. The ‘arr’ array contains 13 pairs of
integers representing the x and y coordinates, and the ‘arr2’ array contains 13 pairs of integers
representing the indices of the line segments in the ‘arr’ array.
The function then uses a loop to iterate over the 13 line segments, creating a tuple ‘coords’ containing
the start and end coordinates of each line segment. Inside the loop, the function calls the ‘draw_line’
function, which draws the line segment on the ‘image’ vector using the input ‘color’, ‘width’, and
‘height’. This process repeats for each line segment, resulting in a repeating texture pattern drawn
on the image vector.
In summary, the ‘generate_repeating_texture_image’ function creates a repeating texture image
by drawing a series of line segments on an image vector using a predefined background color and
an input color for the texture pattern. The function achieves this by iterating through a series of
coordinates and line segment indices, drawing the texture pattern on the image vector using the
‘draw_line’ function.
‘render_repeating_texture_image’ renders a repeating texture image by tiling a smaller texture

image across a larger image. The function takes five input parameters: a vector of tuples representing
the colors of the texture image, the width and height of the texture image (tw and th), a vector of
tuples representing the colors of the output image, and the width and height of the output image (iw
and ih).
The function uses two nested loops to iterate over the width and height of the output image. Inside
the inner loop, the function calculates the corresponding position in the texture image using the
modulo operator. The x and y coordinates of the output image are calculated as the remainder of
the division of the x and y coordinates by (tw - 1) and (th - 1), respectively. This approach ensures
that the texture image will be repeated across the output image, creating a tiled pattern.
Once the corresponding position in the texture image is determined, the function retrieves the color
at that position using the ‘get_index’ function, which computes the index in the vector based on
the x, y coordinates, and the texture image width (tw). The retrieved color is then assigned to the
output image vector at the current position ‘(x, y)’ using the ‘get_index’ function with the output
image width (iw).
‘do_cookie_cut’ extracts a rectangular region, referred to as a “cookie,” from a larger image. The
function takes eight input parameters: a vector of tuples representing the colors of the input image,
the width and height of the input image (w and h), a vector of tuples representing the colors of the
output “cookie” image, the width and height of the “cookie” image (cw and ch), and the starting x
and y coordinates (startx and starty) of the region to extract from the input image.
The function initializes two variables, ‘cx’ and ‘cy’, which will be used to store the x and y
coordinates of the “cookie” image as it is being constructed. It then uses two nested loops to iterate
over the rectangular region defined by the starting coordinates (startx and starty) and the width and
height of the “cookie” image (cw and ch).
Inside the inner loop, the function retrieves the color from the input image at the current position
‘(x, y)’ using the ‘get_index’ function, which computes the index in the vector based on the x, y
coordinates and the input image width (w). The retrieved color is then assigned to the “cookie”
image vector at the position (cx, cy) using the get_index function with the “cookie” image width
(cw).
After each iteration of the inner loop, the function increments the x-coordinate of the “cookie” image
(cx) by 1. After each iteration of the outer loop, the function increments the y-coordinate of the
“cookie” image (cy) by 1 and resets the x-coordinate (cx) back to 0.
‘add_honeycomb’ overlays a texture image onto an input image using an alpha channel image to
control the blending. The function takes four input parameters: a vector of tuples representing the
colors of the input image, a vector of tuples representing the colors of the alpha channel image, a
vector of tuples representing the colors of the texture image, and the width and height of the images
(w and h). The width and height are assumed to be the same for all three images.
First, the function initializes three color tuple variables (color1, color2, and color3) and a pink color
tuple, which will be used later to determine if a pixel should be affected by the texture overlay.
The function then iterates over the width and height of the input image using two nested loops.
Inside the inner loop, the function checks if the current pixel in the texture image is not equal to the
pink color. If it is not pink, the pixel will be affected by the texture overlay.
Next, the function retrieves the colors from the input image, texture image, and alpha channel image
at the current position ‘(x, y)’ using the ‘get_index’ function. The retrieved colors are assigned to
the corresponding color tuple variables (color1, color2, and color3).
The function then calculates the blended color by multiplying the texture color (color2) with the
alpha value (color3) and adding the input image color (color1) multiplied by the inverse of the alpha
value (1.0f - color3). This process is done separately for the red, green, and blue channels, resulting
in the final blended color components (ir, ig, and ib).
Finally, the blended color is assigned to the input image vector at the current position ‘(x, y)’ using
the ‘get_index’ function. This process updates the input image with the texture overlay, effectively
modifying the input image in-place.
‘stamp_cookie’ pastes a smaller image, referred to as a “cookie,” onto a larger image at a specified
position. The function takes eight input parameters: a vector of tuples representing the colors of
the input image, the width and height of the input image (w and h), a vector of tuples representing
the colors of the “cookie” image, the width and height of the “cookie” image (cw and ch), and the
starting x and y coordinates (startx and starty) of the position where the “cookie” image should be
pasted onto the input image.
The function initializes two variables, ‘cx’ and ‘cy’, which will be used to store the x and y
coordinates of the “cookie” image as it is being pasted onto the input image. It then uses two nested
loops to iterate over the rectangular region defined by the starting coordinates (startx and starty)
and the width and height of the “cookie” image (cw and ch).
Inside the inner loop, the function retrieves the color from the “cookie” image at the current position
‘(cx, cy)’ using the ‘get_index’ function, which computes the index in the vector based on the x,
y coordinates and the “cookie” image width (cw). The retrieved color is then assigned to the input
image vector at the position ‘(x, y)’ using the ‘get_index’ function with the input image width (w).
After each iteration of the inner loop, the function increments the x-coordinate of the “cookie” image
(cx) by 1. After each iteration of the outer loop, the function increments the y-coordinate of the
“cookie” image (cy) by 1 and resets the x-coordinate (cx) back to 0.
The ‘draw_hexagon’ function is designed to draw a hexagon with a specified color onto an image.
The function takes eight parameters: a vector of tuples representing the colors of the input image, a
tuple representing the color of the hexagon, the x and y coordinates of the hexagon’s center (centerx
and centery), the hexagon’s radius, the width and height of the input image, and the “circle radius”
(cradius) used for drawing the lines that make up the hexagon.
First, the function initializes some variables used for calculating the hexagon’s vertices. It computes
the upper-left corner of a bounding box around the hexagon, given by ‘(ux, uy)’. It also initializes
six points (pt1x, pt1y) to (pt6x, pt6y), all initially set to ‘(ux, uy)’.
Next, the function calculates some auxiliary variables (A, B, C) using trigonometric formulas
involving the given hexagon radius and a constant PI value. The purpose of these calculations
is to help determine the coordinates of the hexagon’s vertices.
Using the auxiliary variables, the function computes the coordinates of each vertex of the hexagon
(pt1 to pt6). Each vertex’s x and y coordinates are updated based on the initial ‘(ux, uy)’ position
and the auxiliary variables.
The function then creates a vector of tuples called ‘points’ that will be used to store the points along
the lines that form the hexagon. For each pair of adjacent vertices, the function generates the line
points between them using the ‘get_line_points’ function and stores the result in the ‘points’ vector.
Then, the ‘draw’ function is called to draw the line using the points, the input image, the specified
color, the image dimensions, and the “circle radius” (cradius). After drawing each line, the function
clears the ‘points’ vector to prepare it for the next line.
The ‘flood_fill’ function is a simple recursive algorithm used to replace a specific color in an image
with another color within a connected region. It takes six parameters: a vector of tuples representing
the colors of the input image, the x and y coordinates of the starting point, tuples representing the
old and new colors, and the width of the input image.
The function begins by checking if the color at the current coordinates (x, y) in the image is equal
to the old color specified. If the colors match, it replaces the old color at that position with the new
color. Then, the function recursively calls itself to perform the flood fill operation in four directions:
right (x+1, y), down (x, y+1), left (x-1, y), and up (x, y-1).
This process continues until the function reaches pixels with a color different from the old color,
effectively filling the connected region of pixels with the new color.
An image is being created with various hexagons drawn on it. The code starts by declaring a vector
of tuples called ‘image8’, which will represent the colors in the image. The ‘image8’ vector is
resized to fit the dimensions of the image, which are calculated using the ‘calc_size(width, height)’
function.
Next, the ‘fcolor’ tuple is created using the ‘std::make_tuple’ function with RGB values (1.0f, 1.0f,
1.0f), representing the color white. The ‘draw_hexagon’ function is then called four times with
different parameters, each time drawing a hexagon on ‘image8’ with the specified color, center
coordinates, radius, image width, image height, and circle radius used for drawing the hexagon
lines.
The first hexagon is drawn with its center at (784, 340) and a radius of 190. The second hexagon is
drawn with its center at (520, 500) and a radius of 143. The third hexagon is drawn with its center
at (730, 610) and a radius of 107. Finally, the fourth hexagon is drawn with its center at (900, 680)
and a radius of 76.
The ‘blend_hexagon’ function is designed to blend two images, represented by the vectors ‘blend1’
and ‘blend2’, based on a specific color condition. The function takes in four parameters: the two
image vectors ‘blend1’ and ‘blend2’, and the dimensions of the images, ‘width’ and ‘height’.
First, the function initializes two color tuples, ‘color1’ and ‘color2’. ‘color1’ is initialized to (0.0f,
0.0f, 0.0f), which represents black, while ‘color2’ is initialized to (1.0f, 1.0f, 1.0f), which represents
white. The function also initializes three float variables, ‘r’, ‘g’, and ‘b’, and an ‘alpha’ variable with
a value of 0.8f. The ‘alpha’ value will be used to blend the colors from the two images.
The function then iterates through all the pixels in the images using nested for-loops. For each pixel,
it checks if the color of the corresponding pixel in ‘blend2’ is equal to ‘color2’, which is white. If
the condition is met, it retrieves the color of the corresponding pixel in ‘blend1’ and blends it with
black (0.0f, 0.0f, 0.0f), using the ‘alpha’ value to determine the degree of blending.
After blending the colors, the result is stored back in the ‘blend1’ image at the corresponding pixel
position. The blending is performed by multiplying each color component (red, green, and blue) of
the color from ‘blend1’ by the ‘alpha’ value, then adding the product of the black color component
and (1.0f - ‘alpha’). The new color tuple is created using the ‘std::make_tuple’ function and is
assigned to the corresponding pixel in the ‘blend1’ image.
The ‘add_white_hexagon_border’ function is designed to add a white border to an image based

on the white pixels in another image. The function takes in four parameters: two image vectors,
‘image1’ and ‘image2’, and the dimensions of the images, ‘width’ and ‘height’.
First, the function initializes a color tuple named ‘color’ with the values (1.0f, 1.0f, 1.0f), which
represents the color white.
Next, the function iterates through all the pixels in the images using nested for-loops. For each pixel,
it checks if the color of the corresponding pixel in ‘image2’ is equal to ‘color’, which is white. If the
condition is met, it sets the color of the corresponding pixel in ‘image1’ to white.
The ‘draw_label_lines’ function is designed to draw multiple lines on an image with a specific color
and thickness. The function accepts five parameters: a reference to the image vector, a reference
to the color tuple, the width and height of the image, and the thickness of the lines represented as
radius.
First, the function initializes a ‘coords’ tuple, which will store the coordinates of the starting and
ending points of the lines to be drawn. It also initializes a ‘points’ vector, which will store the points
on the line.
This code defines a function called ‘draw_labels’ that takes three arguments: a reference to a vector
of tuples called ‘image’, a reference to a tuple called ‘color’, and two integers called ‘width’ and
‘height’. The function is designed to draw labels on an image using a specified color.
The image is represented by a vector of tuples, where each tuple contains three floating-point values
representing the red, green, and blue channels of a pixel. The ‘color’ tuple also contains three
floating-point values that represent the red, green, and blue channels of the desired color for the
labels.
The ‘draw_labels’ function begins by defining a hard-coded label called ‘lable_10’, which is a
series of 0s and 1s that represent the pixel values of an image. This label was created in a graphics
application and converted to a binary format to be used in this function. The 0s represent transparent
pixels, while the 1s represent the color specified by the ‘color’ argument.
The purpose of the function is to draw this ‘lable_10’ on the ‘image’ using the specified ‘color’,
‘width’, and ‘height’. However, the provided code only defines the ‘lable_10’ data and does not
include the necessary steps to draw the label on the image. The actual drawing process would
involve iterating through the lable_10 data, and for each 1 encountered, setting the corresponding
pixel in the ‘image’ vector to the specified ‘color’.
Pie chart in PPM, take a look in Appendix A: 16_draw_market_size.cpp

11.7 Draw a more advanced chart 2

The code is designed to create a noise image. It is composed of two main parts: variable declarations
and initialization, and a function definition. The code first defines a vector of tuples called ‘image1’
to store the noise image data. Each tuple contains three float values that represent the red, green,
and blue channels of a pixel. The width and height of the image are then set to 1600 and 900
pixels, respectively. The ‘image1’ vector is resized to the appropriate size using the ‘calc_size(width,
height)’ function.
The ‘generate_noise_image’ function is defined to create the noise image. It takes a reference to
a vector of tuples (‘image’), as well as the width and height of the image as its parameters. The
function generates a random grayscale color for each pixel in the image using a random number
generator (‘std::mt19937’) seeded by a random device (‘std::random_device’). The random number
generator is used to create a uniform distribution of float values between 0.0 and 1.0, which represent
the intensity of the grayscale color.
In the nested for loop, the code iterates through each pixel of the image. It generates a random
number (‘rndnum’) using the uniform distribution and the random number generator. This random
number is then used to create a grayscale color by setting the red, green, and blue channels to the
same value (‘rndnum’). The color is stored as a tuple and assigned to the corresponding index in
the ‘image’ vector using the ‘get_index(x, y, width)’ function. This process is repeated for all the
pixels in the image, resulting in a noise image.
Step #1: 16_draw_investment1.ppm
This C++ code generates a linear gradient image. It consists of two main parts: the declaration and
initialization of variables, and the definition of the ‘generate_linear_gradient_image’ function.
In the first part of the code, a vector of tuples called ‘image2’ is created to store the linear gradient
image data. Each tuple holds three float values representing the red, green, and blue channels of
a pixel. The width and height of the image are assumed to be already defined with values of 1600
and 900 pixels, respectively. The ‘image2’ vector is resized to the appropriate size using the ‘calc_-
size(width, height)’ function. The code then defines two tuples, ‘fcolor’ and ‘tcolor’, representing
the starting and ending colors of the gradient, and calls the ‘generate_linear_gradient_image’
function.
The ‘generate_linear_gradient_image’ function is defined to create the linear gradient image. It
takes a reference to a vector of tuples (‘image’), references to the starting and ending colors (‘fcolor’
and ‘tcolor’), and the width and height of the image as its parameters. The function calculates the
color of each pixel in the image by interpolating between the starting and ending colors based on
the pixel’s position.

First, the red, green, and blue channels of the starting and ending colors are extracted using the
‘std::tie’ function. Then, the code iterates through the height of the image using a for loop. In
each iteration, it calculates the interpolation percentage based on the current vertical position of
the pixel. The red, green, and blue channels of the interpolated color are calculated by linearly
interpolating between the corresponding channels of the starting and ending colors using the
calculated percentage. The interpolated color is then stored as a tuple.
In the inner for loop, the code iterates through the width of the image. For each pixel in the
current row, the code assigns the interpolated color to the corresponding index in the ‘image’ vector
using the ‘get_index(x, y, width)’ function. This process is repeated for all the rows in the image,
ultimately generating a linear gradient image.
‘blended_two_images’ takes two input images and blends them together based on a specified alpha
value. The images are passed as vectors of tuples (float, float, float), representing the red, green, and
blue (RGB) color values of each pixel. The function also takes the width and height of the images
and an alpha value, which is a float between 0 and 1.
The function starts by initializing three tuples named ‘color1’, ‘color2’, and three float variables ‘r’,
‘g’, and ‘b’ that will be used to store the RGB values of each pixel in the two images and the resultant
blended image. Two nested for loops are then used to iterate through each pixel in the input images.
The outer loop iterates through the rows (height), while the inner loop iterates through the columns
(width).
For each pixel, the corresponding color values are retrieved from the input images using the ‘get_-
index’ function and stored in ‘color1’ and ‘color2’. The red, green, and blue values of the blended
image are calculated by multiplying the corresponding color values from the second image by the
alpha value, and the color values from the first image by (1 - alpha), then summing them. These
blended RGB values are then stored in the first image vector using the ‘get_index’ function again.
Once the loops have finished iterating through all the pixels, the function has effectively modified
the first input image vector to store the blended image, while the second input image vector remains
unchanged.
‘generate_radial_gradient_image’ creates a radial gradient image with a specified size and two
colors. The radial gradient image is stored as a vector of tuples (float, float, float), representing the
red, green, and blue (RGB) color values of each pixel.
The function takes the following parameters: a reference to the image vector, references to two color
tuples (fcolor and tcolor), and the width and height of the image. The function starts by initializing
some variables: ‘color’ (a tuple to store the current pixel’s color), ‘pink’ (a pre-defined color tuple),
‘mask’ (a vector to store a circular mask), ‘distanceFromCenter’, ‘resultRed’, ‘resultGreen’, and
‘resultBlue’.
The first nested for loops fill the ‘mask’ and ‘image’ vectors with the ‘pink’ color and ‘fcolor’
respectively. Then, the function calculates the midpoint of the image (x0, y0) and initializes variables
‘d’, ‘xx’, and ‘yy’ to draw a circle using Bresenham’s circle algorithm.
A lambda function ‘drawline’ is defined within the function to draw horizontal lines between two
points (sx, ex) at the given y-coordinate (ny) in the ‘mask’ vector. The while loop uses Bresenham’s
circle algorithm to create a circular mask by drawing lines in the ‘mask’ vector using the ‘drawline’
function.
Finally, another set of nested for loops iterates through each pixel in the image. For each pixel, it
checks if the corresponding mask pixel is not equal to the ‘pink’ color. If so, it calculates the distance
from the center of the image to the current pixel and computes the interpolated color values based on
the distance and input colors (fcolor and tcolor). The resulting color tuple is assigned to the ‘image’
vector at the current position. If the mask pixel is equal to the ‘pink’ color, the ‘tcolor’ is assigned
directly to the ‘image’ vector.
‘generate_repeating_texture_image’ generates a repeating texture pattern with a given width,

height, and color. The texture image is stored as a vector of tuples (float, float, float), representing
the red, green, and blue (RGB) color values of each pixel.
The function takes the following parameters: a reference to the image vector, a reference to the
color tuple, and the width and height of the image. It begins by initializing a background color tuple
named ‘bgcolor’ to be a pinkish color. Then, using two nested for loops, it fills the ‘image’ vector
with this background color.
The function proceeds to define two integer arrays ‘arr’ and ‘arr2’ with hardcoded coordinates and
indices, representing the positions and connections of points in the pattern. The ‘coords’ tuple is
initialized to store the coordinates of the line endpoints in the pattern.
Next, the function iterates through the 13 hardcoded points using a for loop. During each iteration,
it creates a ‘coords’ tuple using the coordinates from the ‘arr’ array based on the indices found in
the ‘arr2’ array. The ‘draw_line’ function is then called with the ‘image’ vector, ‘coords’ tuple,
input color, width, and height as parameters. This function draws lines between the coordinates
specified by the ‘coords’ tuple in the image vector using the input color.
‘render_repeating_texture_image’ takes a texture image and renders it repeatedly across a larger

image. Both the texture and the larger image are stored as vectors of tuples (float, float, float),
representing the red, green, and blue (RGB) color values of each pixel.
The function takes the following parameters: a reference to the texture vector, the width and height
of the texture (tw, th), a reference to the image vector, and the width and height of the image (iw,
ih). It uses two nested for loops to iterate through each pixel in the larger image. For each pixel,
the function retrieves the corresponding color value from the texture vector using the ‘get_index’
function, with the x and y coordinates of the pixel modulo (tw-1) and (th-1), respectively. This
ensures that the texture is repeated across the entire image. The retrieved color value is then assigned
to the corresponding pixel in the image vector.
‘do_cookie_cut’ extracts a rectangular section from a source image and stores it in another image,
often referred to as ‘cookie-cutting’. Both the source image and the resulting image are stored as
vectors of tuples (float, float, float), representing the red, green, and blue (RGB) color values of each
pixel.
The function takes the following parameters: a reference to the source image vector, the width and
height of the source image (w, h), a reference to the resulting image vector, the width and height of
the resulting image (cw, ch), and the starting x and y coordinates (startx, starty) of the rectangular
section to be extracted from the source image. It initializes two variables, cx and cy, to keep track
of the current x and y coordinates in the resulting image.
The function uses two nested for loops to iterate through the rectangular section of the source image,
starting from the specified starting coordinates (startx, starty) and covering the width and height
of the resulting image (cw, ch). For each pixel in the section, it copies the color value from the
source image to the corresponding position in the resulting image, using the ‘get_index’ function
to convert the 2D coordinates to a linear index. The cx and cy variables are updated accordingly to
move through the resulting image.
‘add_honeycomb’ combines three images: a base image, an alpha image, and a texture image. The
base image and the texture image are combined using the red channel of the alpha image as a weight.
All three images are stored as vectors of tuples (float, float, float), representing the red, green, and
blue (RGB) color values of each pixel.
The function takes the following parameters: references to the base image vector, alpha image vector,
texture image vector, and the width and height of the images (w, h). It initializes several tuple
variables to store the color values of the three images at each pixel and a pink color tuple (1.0f, 0.0f,
1.0f) to check against the texture image.
Using two nested for loops, the function iterates through each pixel of the images. If the color value
of the texture image at the current pixel is not pink, the function retrieves the color values of the
base, texture, and alpha images at the current pixel. It then calculates the new red, green, and blue
color values for the base image by interpolating between the texture and base images’ color values
using the red channel of the alpha image as a weight. The resulting color value is assigned back to
the base image at the current pixel.
‘stamp_cookie’ places a smaller ‘cookie’ image onto a larger base image at a specified position. The
base image and the cookie image are stored as vectors of tuples (float, float, float), representing the
red, green, and blue (RGB) color values of each pixel.
The function takes the following parameters: references to the base image vector, its width and
height (w, h), the cookie image vector, its width and height (cw, ch), and the starting x and y
coordinates (startx, starty) for placing the cookie image onto the base image.
The function initializes two integer variables, cx and cy, to keep track of the current position within
the cookie image. It then uses two nested for loops to iterate through each pixel of the area where
the cookie image will be placed on the base image.
For each pixel in the specified area, the function retrieves the color value from the cookie image at the
current cx and cy coordinates and assigns it to the base image at the current x and y coordinates. The
cx variable is incremented for each iteration of the inner loop, while the cy variable is incremented
for each iteration of the outer loop. After the inner loop is completed, the cx variable is reset to 0 to
start processing the next row of the cookie image.
The code creates an image of a doughnut shape with various shades of gray and white, as well as
some additional labels. The doughnut consists of a series of filled wedges and lines drawn on a base
image.
The base image, ‘image7’, is initialized as a vector of tuples (float, float, float), representing the red,
green, and blue (RGB) color values of each pixel. The base image is then resized to the desired width
and height.
The image is first cleared to a solid color (magenta) using the ‘clear_image’ function. Next, the
doughnut shape is constructed by drawing filled wedges and lines with different shades of gray and
white. The ‘draw_filled_wedge’ function is used to draw the filled wedges, while the ‘draw_line’
function is used to draw the lines. Each of these functions takes the image, coordinates, and color
information as input.
Finally, the ‘draw_labels’ function is called to add labels to the image. This function takes the image,
color (white), width, and height as input.
The code adds the previously created doughnut shape to the ‘image1’ by copying the non-magenta
pixels from ‘image7’ to ‘image1’. The magenta color (1.0f, 0.0f, 1.0f) is used as a background color
in ‘image7’ and is not copied to ‘image1’.
The code first defines the magenta color as ‘fcolor’, which will be used to identify the background
pixels that should not be copied.
Then, two nested loops iterate over the height and width of the images. For each pixel coordinate (x,
y), the code checks if the pixel in ‘image7’ is not magenta (i.e., not equal to ‘fcolor’). If the condition
is true, the non-magenta pixel from ‘image7’ is copied to the corresponding position in ‘image1’.
In summary, the code adds the doughnut shape from ‘image7’ to ‘image1’ by copying only the
non-magenta pixels from ‘image7’ to their corresponding positions in ‘image1’.
Pie chart in PPM, take a look in Appendix A: 16_draw_investment.cpp

11.8 Collaboration
We can use 2D charts and diagrams to help us understand and solve problems collaboratively. For
example, we can use a chart to visualize the relationships between different elements in a problem
or a diagram to explore the potential solutions to a problem.
2D charts and diagrams are also helpful for communicating our ideas to others. We can use them
to explain our thinking process or present our findings clearly and concisely.
When working with 2D graphs and diagrams, it is vital to know the different types of data they
can represent. For instance, some charts are better suited for displaying quantitative data, while
others are more effective for visualizing qualitative data. Additionally, we must be careful when
interpreting data from 2D graphs and diagrams, as they can sometimes be misleading.
Despite these limitations, 2D graphs and diagrams are powerful tools that can help us think more
creatively and solve problems more effectively. With a bit of practice, we can learn to use them in
various ways to improve our collaborative problem-solving skills.
Peacock chart in PPM, take a look in Appendix A: 17_colab_peacock.cpp
peacock graph
11.9 Investigation
There is a reason that businesses, law enforcement agencies, military intelligence use data visualiza-
tion when investigating crimes or irregularities - it works. By taking large data sets and representing
them in an easily digestible format, investigators can quickly identify patterns and relationships
that would otherwise be difficult to spot. The right data can help investigators piece together what
happened and who was involved.
Also for a security incident a simple graph can give you some important information as when
something happend and the amout of actvity. Also what kind of activity in the log.
Investigating log
12 PPM++ header-only library
Hello everyone,
I am pleased to announce the release of my c++ header-only library for 2D graphics. This library is
designed to make it easy to create beautiful and performant 2D graphics applications using c++17.
It is available on Github under the MIT license. I would love to hear your feedback!
You’ll find the header-only library here: https://gist.github.com/chbtoys/cdd6a85e321593ea0a1e7141d0a09fbc
… and a test.cpp here: https://gist.github.com/chbtoys/a665b52f86768b8e601c82b47ce18e49
Or clone from Github.com.
1 git clone https://github.com/chbtoys/ppmpp.git

2 cd ppmpp
3 clang++ -std=c++20 test.cpp -o test
4 ./test
(C++20 for std::lerp when creating bezier curves)

13 In the Rearview Mirror
What’s next? Maybe make a header-only .HPP framework of your own or extend the one that
already exists.
There are of course more 2D graphic techniques then included in the book. Please, feel free to
expande the code the way you want.
There are some helpfull tools that definitely is nice to have. Image Magick1 to convert PPM to
PNG/JPG/GIF and FFMPEG2 to combine still images into a animation. Both are nice tools to have.
Thank you for your time.
1 https://imagemagick.org/index.php
2 https://ffmpeg.org/
14 Appendix A: Source Code Listings
01_tuples.cpp - 1521 bytes.
1 // Compile: clang++ -std=c++17 01_tuples.cpp -o 01_tuples

2
3 #include <iostream>
4 #include <tuple>
5
6 std::tuple<int, int, int> get_rgb_elements_as_a_tuple(int r, int g, int b)
7 {
8 return std::make_tuple(r, g, b);
9 }
10
11 int main()
12 {
13 int r1=212; int g1=24; int b1=118;
14 int r2=0; int g2=0; int b2=0;
15 int r3=0; int g3=0; int b3=0;
16 std::tuple<int, int, int> rgb;
17
18 std::cout << "r1: " << r1 << " g1: " << g1 << " b1: " << b1 << std::endl;
21
22 std::cout << "rgb=get_rgb_elements_as_a_tuple(r1, g1, b1);" << std::endl;
23 rgb=get_rgb_elements_as_a_tuple(r1, g1, b1);
24
25 // unroll #1
26 std::cout << "unroll #1" << std::endl;
27 r2=std::get<0>(rgb);
28 g2=std::get<1>(rgb);
29 b2=std::get<2>(rgb);
30 std::cout << "r2=std::get<0>(rgb); g2=std::get<1>(rgb); b2=std::get<2>(rgb);" << st\
31 d::endl;
35 // unroll #2
36 std::cout << "unroll #2" << std::endl;
14 Appendix A: Source Code Listings 61
37 std::tie(r3, g3, b3) = rgb;

38 std::cout << "std::tie(r3, g3, b3) = rgb;" << std::endl;
42
43 return 0;
44 }
02_index.cpp - 1630 bytes.
1 // Compile: clang++ -std=c++17 02_index.cpp -o 02_index

2
4
5 int get_index(int x, int y, int width)
6 {
7 return x+width*y;
8 }
9
10 int main()
11 {
12 int width=10;
13 int x=0;
14 int y=0;
15
16 std::cout << "Index: " << get_index(x,y,width) << " (for X:" << x << " Y:" << y << \
17 ")" << std::endl;
18 y=1;x=5;
20 ")" << std::endl;
21 y=2;x=3;
23 ")" << std::endl;
24 y=3;x=2;
26 ")" << std::endl;
27 y=4;x=3;
29 ")" << std::endl;
30 y=6;x=6;
32 ")" << std::endl;
33 y=7;x=2;
35 ")" << std::endl;
36 y=9;x=8;
38 ")" << std::endl << std::endl;
39
40 std::cout << " 0123456789" << std::endl;
41 std::cout << "0+---------- I: 0" << std::endl;
42 std::cout << "1-----+----- I: 15" << std::endl;
43 std::cout << "2---+------- I: 23" << std::endl;
44 std::cout << "3--+-------- I: 32" << std::endl;
45 std::cout << "4---+------- I: 43" << std::endl;
46 std::cout << "5----------- N/A" << std::endl;
47 std::cout << "6------+---- I: 66" << std::endl;
48 std::cout << "7--+-------- I: 72" << std::endl;
49 std::cout << "8----------- N/A" << std::endl;
50 std::cout << "9--------+-- I: 98" << std::endl;
51
52 return 0;
53 }
03_calcsize.cpp - 908 bytes.
1 // Compile: clang++ -std=c++17 03_calcsize.cpp -o 03_calcsize

2
4 #include <tuple>
5 #include <vector>
6
8 {
9 return x+width*y;
10 }
11
12 int calc_size(int width, int height)
13 {
14 return width*height;
15 }
16
17 void clear_image(std::vector<std::tuple<float, float, float>> &image, std::tuple<flo\
18 at, float, float> &color, int width, int height)
19 {
20 for (int y=0;y<height;++y) {

21 for (int x=0;x<width;++x) {
22 image[get_index(x,y,width)]=color;
23 }
24 }
25 }
26
27 int main()
28 {
29 std::vector<std::tuple<float, float, float>> image;
30 std::tuple<float, float, float> color=std::make_tuple(0.0f,0.0f,0.0f);
31 int width=640;
32 int height=360;
33
34 image.resize(calc_size(width, height));
35 std::cout << "Created a vector with the size: " << calc_size(width, height) << std:\
36 :endl;
37 clear_image(image,color,width,height);
38 std::cout << "Cleared image with black color." << std::endl;
39
40 return 0;
41 }
04_helloworld.cpp - 2265 bytes.
1 // Compile: clang++ -std=c++17 04_helloworld.cpp -o 04_helloworld

2
4 #include <fstream>
5 #include <tuple>
6 #include <vector>
7
9 {
10 return x+width*y;
11 }
12
14 {
16 }
17

20 {
24 }
25 }
26 }
27
28 void first_draw(std::vector<std::tuple<float, float, float>> &image, int width, int \
29 height)
30 {
31 std::tuple<float, float, float> color;
32 int ctr=0;
33 for (int y=height-1;y>=0;--y)
34 {
36 float r = float(x) / float(width);
37 float g = float(y) / float(height);
38 float b = 0.2;
39 color=std::make_tuple(r, g, b);
40 image[ctr]=color;
41 ctr++;
42 }
43 }
44 }
45
46 void save_image(std::vector<std::tuple<float, float, float>> &image, int width, int \
47 height, std::string filename)
48 {
50 std::ofstream out(filename, std::ofstream::out);
51 out << "P3\n" << width << " " << height << "\n255\n";
52 for (int i=0;i<(width*height);++i)
53 {
54 color=image[i];
55 out << int(std::get<0>(color)*255.0f) << " " << int(std::get<1>(color)*255.0f) << \
56 " " << int(std::get<2>(color)*255.0f) << '\n';
57 }
58 out.close();
59 }
60
61 int main()
62 {
65 int width=640;
66 int height=360;
67
70 :endl;
72 std::cout << "Cleared image with dark blue color." << std::endl;
73 first_draw(image,width,height);
74 std::cout << "Drawing the first image pixel by pixel" << std::endl;
75 save_image(image,width,height,"04_helloworld.ppm");
76 std::cout << "Saved: 04_helloworld.ppm" << std::endl;
77
78 // Create square (for 08; blending colors).
79 std::vector<std::tuple<float, float, float>> square;
80 width=256;height=256;
81 square.resize(calc_size(width, height));
82 first_draw(square,width,height);
83 save_image(square,width,height,"04_helloworld_square.ppm");
84
85 return 0;
86 }
05_randomwalker.cpp - 5472 bytes.
1 // Compile: clang++ -std=c++17 05_randomwalker.cpp -o 05_randomwalker

2
5 #include <tuple>
6 #include <vector>
7 #include <random>
8 #include <algorithm>
9
10 bool startsWithCaseInsensitive(std::string mainStr, std::string toMatch)
11 {
12 // Convert mainStr to lower case
13 std::transform(mainStr.begin(), mainStr.end(), mainStr.begin(), ::tolower);
14 // Convert toMatch to lower case
15 std::transform(toMatch.begin(), toMatch.end(), toMatch.begin(), ::tolower);
16 if(mainStr.find(toMatch) == 0)
17 return true;
18 else
19 return false;
20 }
21
23 {
25 }
26
28 {
30 }
31
34 {
38 }
39 }
40 }
41
44 {
49 {
50 color=image[i];
53 }
54 out.close();
55 }
56
57 std::tuple<int,int> get_width_and_height(const std::string str)
58 {
59 size_t start;
60 size_t end = 0;
61 std::vector<std::string> out;
62
63 while ((start = str.find_first_not_of(' ', end)) != std::string::npos)
64 {
65 end = str.find(' ', start);
66 out.push_back(str.substr(start, end - start));
67 }
68
69 int w=stoi(out[0]);
70 int h=stoi(out[1]);
71
72 return std::make_tuple(w,h);
73 }
74
75 std::tuple<int,int,int> get_color(const std::string str)
76 {
77 size_t start;
78 size_t end = 0;
80
82 {
85 }
86
87 int r=stoi(out[0]);
88 int g=stoi(out[1]);
89 int b=stoi(out[2]);
90
91 return std::make_tuple(r,g,b);
92 }
93
94 void read_image(std::vector<std::tuple<float, float, float>> &image, int &width, int\
95 &height, std::string filename)
96 {
97 std::ifstream infile(filename);
98 std::tuple<int, int, int> rcolor;
99 std::tuple<float, float, float> wcolor;
100 std::tuple<int,int> widthnheight;
101 std::string line;
102 int state=0;

103 bool done = false;
104
105 while (getline(infile, line))
106 {
107 if (startsWithCaseInsensitive(line,"P3") && state == 0) {
108 state=1;
109 }
110
111 if (!startsWithCaseInsensitive(line,"#") && !startsWithCaseInsensitive(line,"P3") \
112 && state == 1) {
113 widthnheight=get_width_and_height(line);
114 width=std::get<0>(widthnheight);
115 height=std::get<1>(widthnheight);
116 state=2;
117 }
118
119 if (startsWithCaseInsensitive(line,"255") && state == 2) {
120 state=3;
121 }
122
123 if (!(line.compare("255") == 0) && state == 3) {
124 rcolor=get_color(line);
125 wcolor=std::make_tuple(float(std::get<0>(rcolor)/255.0f), float(std::get<1>(
126 r)/255.0f), float(std::get<2>(rcolor)/255.0f));
127 image.push_back(wcolor);
128 done = true;
129 }
130 }
131 infile.close();
132 }
133
134 void update_x_and_y(int r, std::tuple<int,int> &walk1, std::tuple<int,int> &walk2, i\
135 nt width, int height)
136 {
137 int x1,y1,x2,y2;
138 std::tie(x1,y1) = walk1;
140
141 switch(r) {
142 case 0:
143 x1+=1;
144 x2-=1;
145 break;
146 case 1:
147 x1-=1;
148 x2+=1;
149 break;
150 case 2:
151 y1+=1;
152 y2-=1;
153 break;
154 case 3:
155 y1-=1;
156 y2+=1;
157 break;
158 }
159
160 if (x1 < 0) {
161 x1 = 0;
162 } else if (x1 > width-1) {
163 x1=width-1;
164 }
165
166 if (x2 < 0) {
167 x2 = 0;
169 x2=width-1;
170 }
171
172 if (y1 < 0) {
173 y1 = 0;
174 } else if (y1 > height-1) {
175 y1 = height-1;
176 }
177
178 if (y2 < 0) {
179 y2 = 0;
181 y2 = height-1;
182 }
183
184 walk1=std::make_tuple(x1,y1);
186 }
187
188 void walker(std::vector<std::tuple<float, float, float>> &image1, std::vector<std::t\

189 uple<float, float, float>> &image2, int width, int height)
190 {
191 // Randomize and draw walkers
193 int x1=width/2;
194 int y1=height/2;
195 int x2=width/2;
197
198 std::random_device rd;
199 std::mt19937 mt(rd());
200 std::uniform_int_distribution<> dist(0, 3);
201
202 std::tuple<int,int> walk1=std::make_tuple(x1,y1);
204
205 int r=0;
206 for (int i=0;i<100000;++i) {
207 r=dist(mt);
208 update_x_and_y(r,walk1,walk2,width,height);
209 color=image1[get_index(std::get<0>(walk1), std::get<1>(walk1), width)];
210 image2[get_index(std::get<0>(walk1), std::get<1>(walk1), width)]=color;
213 }
214 }
215
216 int main()
217 {
218 std::vector<std::tuple<float, float, float>> image1;
221 int width=0;
222 int height=0;
223
224 read_image(image1, width, height, "04_helloworld.ppm");
225
226 image2.resize(calc_size(width, height));
228 :endl;
229 clear_image(image2,color,width,height);
231 // Random Walker

232 walker(image1,image2,width,height);
233 save_image(image2,width,height,"05_randomwalker.ppm");
234 std::cout << "Saved: 05_randomwalker.ppm" << std::endl;
235
236 return 0;
237 }
06_xor_and_or_texture.cpp - 3095 bytes.
1 // Compile: clang++ -std=c++17 06_xor_and_or_texture.cpp -o 06_xor_and_or_texture

2
5 #include <tuple>
6 #include <vector>
7
9 {
11 }
12
14 {
16 }
17
20 {
24 }
25 }
26 }
27
30 {

35 {
36 color=image[i];
39 }
40 out.close();
41 }
42
43 void draw_xor(std::vector<std::tuple<float, float, float>> &image, int width, int he\
44 ight)
45 {
47 int c=0;
48
49 for (int y=0;y<height;++y)
50 {
52 c = x ^ y;// XOR
53 color=std::make_tuple(float(c/255.0f), float(c/255.0f), float(c/255.0f));
54 image[get_index(x, y, width)]=color;
55 }
56 }
57 }
58
59 void draw_and(std::vector<std::tuple<float, float, float>> &image, int width, int he\
60 ight)
61 {
63 int c=0;
64
66 {
68 c = x & y;// AND
71 }
72 }
73 }
74
75 void draw_or(std::vector<std::tuple<float, float, float>> &image, int width, int hei\
76 ght)
77 {
79 int c=0;
80
82 {
84 c = x | y;// OR
87 }
88 }
89 }
90
91 int main()
92 {
95 int width=256;
96 int height=256;
97
100 :endl;
103 // XOR Texture
104 draw_xor(image,width,height);
105 std::cout << "XOR Texture drawn." << std::endl;
106 save_image(image,width,height,"06_xor_texture.ppm");
107 std::cout << "Saved: 06_xor_texture.ppm" << std::endl;
108 // AND Texture
109 draw_and(image,width,height);
110 std::cout << "AND Texture drawn." << std::endl;
111 save_image(image,width,height,"06_and_texture.ppm");
112 std::cout << "Saved: 06_and_texture.ppm" << std::endl;
113 // OR Texture
114 draw_or(image,width,height);
115 std::cout << "OR Texture drawn." << std::endl;
116 save_image(image,width,height,"06_or_texture.ppm");
117 std::cout << "Saved: 06_or_texture.ppm" << std::endl;
118
119 return 0;
120 }
07_clouds_marble_wood_texture.cpp - 6128 bytes.
1 // Compile: clang++ -std=c++17 07_clouds_marble_wood_texture.cpp -o 07_clouds_marble\

2 _wood_texture
3 #define _USE_MATH_DEFINES
4
7 #include <tuple>
8 #include <vector>
9 #include <random>
10 #include <cmath>
11
13 {
15 }
16
18 {
20 }
21
24 {
28 }
29 }
30 }
31
34 {
39 {
40 color=image[i];
43 }
44 out.close();
45 }
46
47 void generate_noise(std::vector<double> &noise, int width, int height)
48 {
50 std::mt19937 mt(rd());
51 std::uniform_real_distribution<> dist(0.0, 1.0);
52
55 noise[get_index(x,y,width)]=dist(mt);
56 }
57 }
58 }
59
60 double smooth_noise(double x, double y, int width, int height, std::vector<double> &\
61 noise)
62 {
63 // Get fractional part of X and Y.
64 double fractionX = x - int(x);
65 double fractionY = y - int(y);
66
67 // Wrap around.
68 int x1 = (int(x) + width) % width;
69 int y1 = (int(y) + height) % height;
70
71 // Neighbor values.
72 int x2 = (x1 + width - 1) % width;
73 int y2 = (y1 + height - 1) % height;
74
75 // Smoth the noise with bilinear interpolation.
76 double value=0.0;
77 value += fractionX * fractionY * noise[get_index(x1,y1,width)];
78 value += (1 - fractionX) * fractionY * noise[get_index(x2,y1,width)];
79 value += fractionX * (1 - fractionY) * noise[get_index(x1,y2,width)];
80 value += (1 - fractionX) * (1 - fractionY) * noise[get_index(x2,y2,width)];
81
82 return value;
83 }
84
85 double turbulence(double x, double y, int width, int height, double size, std::vecto\
86 r<double> &noise)
87 {
88 double value = 0.0;
89 double initialSize = size;
90
91 while (size >= 1)
92 {
93 value += smooth_noise(x/size,y/size,width,height,noise) * size;
94 size /= 2.0;
95 }
96
97 return (128.0 * value / initialSize);
98 }
99
100 void generate_cloud(std::vector<std::tuple<float, float, float>> &image, int width, \
101 int height, std::vector<double> &noise)
102 {
104 int c=0;
105
107 {
109 c=int(turbulence(double(x),double(y),width,height,64,noise));
112 }
113 }
114 }
115
116 void generate_marble(std::vector<std::tuple<float, float, float>> &image, int width,\
117 int height, std::vector<double> &noise)
118 {
120
121 // xPeriod and yPeriod together define the angle of the lines.
122 // xPeriod and yPeriod both 0 ==> it becomes a normal clouds or turbulence pattern.
123 double xPeriod = 5.0; // Defines repetition of marble lines in x direction.
124 double yPeriod = 10.0; // Defines repetition of marble lines in y direction.
125 // turbulencePower = 0 ==> it becomes a normal sine pattern.
126 double turbulencePower = 5.0; // Makes twists.

127 double turbulenceSize = 32.0; // Initial size of the turbulence.
128
129 double xyValue = 0.0;
130 double sineValue = 0.0;
131
133 {
135 xyValue = x * xPeriod / width + y * yPeriod / height + turbulencePower * tur
136 ce(double(x),double(y),width,height,turbulenceSize,noise) / 255.0;
137 sineValue = 256 * fabs(sin(xyValue * M_PI));
138 color=std::make_tuple(float(sineValue/255.0f), float(sineValue/255.0f), floa
139 eValue/255.0f));
141 }
142 }
143 }
144
145 void generate_wood(std::vector<std::tuple<float, float, float>> &image, int width, i\
146 nt height, std::vector<double> &noise)
147 {
149
150 double xyPeriod = 25.0; // Number of rings.
151 double turbulencePower = 0.1; // Makes twists.
152 double turbulenceSize = 32.0; // Initial size of the turbulence.
153
154 double sineValue = 0.0;
155 double distValue = 0.0;
156 double xValue = 0.0;
157 double yValue = 0.0;
158
160 {
162 xValue = (x - width / 2) / double(width);
163 yValue = (y - height / 2) / double(height);
164 distValue = sqrt(xValue * xValue + yValue * yValue) + turbulencePower * turb
165 e(double(x),double(y),width,height,turbulenceSize,noise) / 255.0;
166 sineValue = 128.0 * fabs(sin(2 * xyPeriod * distValue * M_PI));
167 color=std::make_tuple(float((80 + sineValue)/255.0f), float((30 + sineValue)
168 0f), float(30.0f/255.0f));

170 }
171 }
172 }
173
174 int main()
175 {
176 std::vector<double> noise;
179 int width=256;
180 int height=256;
181
184 :endl;
187 // Generate noise
188 noise.resize(calc_size(width, height));
189 generate_noise(noise,width,height);
190 std::cout << "Generated noise." << std::endl;
191 // Cloud Texture
192 generate_cloud(image,width,height,noise);
193 std::cout << "Generated Cloud." << std::endl;
194 save_image(image,width,height,"07_cloud_texture.ppm");
195 std::cout << "Save Cloud." << std::endl;
196 // Marble Texture
197 generate_marble(image,width,height,noise);
198 std::cout << "Generated Marble." << std::endl;
199 save_image(image,width,height,"07_marble_texture.ppm");
200 std::cout << "Save Marble." << std::endl;
201 // Wood Texture
202 generate_wood(image,width,height,noise);
203 std::cout << "Generated Wood." << std::endl;
204 save_image(image,width,height,"07_wood_texture.ppm");
205 std::cout << "Save Wood." << std::endl;
206
207 return 0;
208 }
08_light_and_color.cpp - 15132 bytes.

1 // Compile: clang++ -std=c++17 08_light_and_color.cpp -o 08_light_and_color
2
5 #include <tuple>
6 #include <vector>
8
10 {
16 return true;
17 else
18 return false;
19 }
20
22 {
24 }
25
27 {
29 }
30
32 {
33 size_t start;
34 size_t end = 0;
36
38 {
41 }
42
45
47 }
48
50 {
51 size_t start;
52 size_t end = 0;
54
56 {
59 }
60
64
66 }
67
70 {
76 int state=0;
78
80 {
82 state=1;
83 }
84
86 && state == 1) {
90 state=2;
91 }
92
94 state=3;
95 }
96
102 done = true;
103 }
104 }
105 infile.close();
106 }
107
108 void negative_image(std::vector<std::tuple<float, float, float>> &image, int width, \
109 int height)
110 {
111 std::tuple<float, float, float> oldColor=std::make_tuple(0.0f,0.0f,0.0f);
114 oldColor=image[get_index(x,y,width)];
115 image[get_index(x,y,width)]=std::make_tuple(1.0f-std::get<0>(oldColor), 1.0f
116 :get<1>(oldColor), 1.0f-std::get<2>(oldColor));
117 }
118 }
119 }
120
121 void double_as_dark(std::vector<std::tuple<float, float, float>> &image, int width, \
122 int height)
123 {
128 image[get_index(x,y,width)]=std::make_tuple(std::get<0>(oldColor) / 2.0f, st
129 t<1>(oldColor) / 2.0f, std::get<2>(oldColor) / 2.0f);

130 }
131 }
132 }
133
134 void onefive_as_dark(std::vector<std::tuple<float, float, float>> &image, int width,\
135 int height)
136 {
141 image[get_index(x,y,width)]=std::make_tuple(std::get<0>(oldColor) / 1.5f, st
142 t<1>(oldColor) / 1.5f, std::get<2>(oldColor) / 1.5f);
143 }
144 }
145 }
146
147 void twice_as_bright(std::vector<std::tuple<float, float, float>> &image, int width,\
148 int height)
149 {
151 float r=0.0; float g=0.0; float b=0.0;
155 r=std::get<0>(oldColor) * 2.0f; g=std::get<1>(oldColor) * 2.0f; b=std::get<2
156 Color) * 2.0f;
157 if (r > 1.0) {r=1.0f;} if (g > 1.0) {g=1.0f;} if (b > 1.0) {b=1.0f;}
158 image[get_index(x,y,width)]=std::make_tuple(r, g, b);
159 }
160 }
161 }
162
163 void add_for_brighter(std::vector<std::tuple<float, float, float>> &image, int width\
164 , int height)
165 {
171 r=std::get<0>(oldColor) + 0.2f; g=std::get<1>(oldColor) + 0.2f; b=std::get<2
172 Color) + 0.2f;

173 if (r > 1.0) {r=1.0f;} if (g > 1.0) {g=1.0f;} if (b > 1.0) {b=1.0f;}
175 }
176 }
177 }
178
179 void sub_for_darker(std::vector<std::tuple<float, float, float>> &image, int width, \
180 int height)
181 {
187 r=std::get<0>(oldColor) - 0.2f; g=std::get<1>(oldColor) - 0.2f; b=std::get<2
188 Color) - 0.2f;
189 if (r < 0.0) {r=0.0f;} if (g < 0.0) {g=0.0f;} if (b < 0.0) {b=0.0f;}
191 }
192 }
193 }
194
195 void greyscale_image(std::vector<std::tuple<float, float, float>> &image, int width,\
196 int height)
197 {
199 float c=0.0;
202 color=image[get_index(x,y,width)];
203 c=(0.2126 * std::get<0>(color))+(0.7152 * std::get<1>(color))+(0.0722 * std:
204 2>(color));
205 if (c > 1.0) {c=1.0f;}
206 image[get_index(x,y,width)]=std::make_tuple(c, c, c);
207 }
208 }
209 }
210
211 void zero_gb_image(std::vector<std::tuple<float, float, float>> &image, int width, i\
212 nt height)
213 {

218 image[get_index(x,y,width)]=std::make_tuple(0.0f, std::get<1>(color), std::g
219 (color));
220 }
221 }
222 }
223
224 void r_zero_b_image(std::vector<std::tuple<float, float, float>> &image, int width, \
225 int height)
226 {
231 image[get_index(x,y,width)]=std::make_tuple(std::get<0>(color), 0.0f, std::g
232 (color));
233 }
234 }
235 }
236
237 void rg_zero_image(std::vector<std::tuple<float, float, float>> &image, int width, i\
238 nt height)
239 {
244 image[get_index(x,y,width)]=std::make_tuple(std::get<0>(color), std::get<1>(
245 ), 0.0f);
246 }
247 }
248 }
249
250 void grb_image(std::vector<std::tuple<float, float, float>> &image, int width, int h\
251 eight)
252 {
258 ), std::get<2>(color));
259 }
260 }
261 }
262
263 void bgr_image(std::vector<std::tuple<float, float, float>> &image, int width, int h\
264 eight)
265 {
272 }
273 }
274 }
275
276 void rrb_image(std::vector<std::tuple<float, float, float>> &image, int width, int h\
277 eight)
278 {
285 }
286 }
287 }
288
289 void blended_two_images(std::vector<std::tuple<float, float, float>> &blend1,std::ve\
290 ctor<std::tuple<float, float, float>> &blend2,int width,int height,float alpha)
291 {
292 std::tuple<float, float, float> color1=std::make_tuple(0.0f,0.0f,0.0f);
294 float r=0.0f; float g=0.0f; float b=0.0f;
295
298 color1=blend1[get_index(x,y,width)];
300 r = (std::get<0>(color2) * alpha) + (std::get<0>(color1) * (1.0f - alpha));
301 g = (std::get<1>(color2) * alpha) + (std::get<1>(color1) * (1.0f - alpha));

302 b = (std::get<2>(color2) * alpha) + (std::get<2>(color1) * (1.0f - alpha));
303 blend1[get_index(x,y,width)]=std::make_tuple(r, g, b);
304 }
305 }
306 }
307
310 {
315 {
316 color=image[i];
319 }
320 out.close();
321 }
322
323 int main()
324 {
326 int width=0;
327 int height=0;
328
329 // Negative Colors.
330 std::cout << "Loading: '04_helloworld.ppm'." << std::endl;
331 read_image(image, width, height, "04_helloworld.ppm");
332 std::cout << "Making a negative color image." << std::endl;
333 negative_image(image,width,height);
334 std::cout << "Saving: '08_negative_image.ppm'." << std::endl;
335 save_image(image,width,height,"08_negative_image.ppm");
336
337 // Double as dark.
338 std::cout << "Reverting to: '04_helloworld.ppm'." << std::endl;
339 image.clear();
341 std::cout << "Making a double as dark image." << std::endl;
342 double_as_dark(image,width,height);
343 std::cout << "Saving: '08_double_as_dark.ppm'." << std::endl;
344 save_image(image,width,height,"08_double_as_dark.ppm");
345
346 // OneFive times as dark.
348 image.clear();
350 std::cout << "Making a 1.5 times as dark image." << std::endl;
351 onefive_as_dark(image,width,height);
352 std::cout << "Saving: '08_onefive_as_dark.ppm'." << std::endl;
353 save_image(image,width,height,"08_onefive_as_dark.ppm");
354
355 // Twice as bright.
357 image.clear();
359 std::cout << "Twice as bright image." << std::endl;
360 twice_as_bright(image,width,height);
361 std::cout << "Saving: '08_twice_as_bright.ppm'." << std::endl;
362 save_image(image,width,height,"08_twice_as_bright.ppm");
363
364 // Add for brighter.
366 image.clear();
368 std::cout << "Add for brighter image." << std::endl;
369 add_for_brighter(image,width,height);
370 std::cout << "Saving: '08_add_for_brighter.ppm'." << std::endl;
371 save_image(image,width,height,"08_add_for_brighter.ppm");
372
373 // Sub for darker.
375 image.clear();
377 std::cout << "Sub for darker image." << std::endl;
378 sub_for_darker(image,width,height);
379 std::cout << "Saving: '08_sub_for_darker.ppm'." << std::endl;
380 save_image(image,width,height,"08_sub_for_darker.ppm");
381
382 // Greyscale image.
384 image.clear();
386 std::cout << "Greyscale image." << std::endl;
387 greyscale_image(image,width,height);
388 std::cout << "Saving: '08_greyscale_image.ppm'." << std::endl;
389 save_image(image,width,height,"08_greyscale_image.ppm");
390
391 // Swapping and removing color channels.
393 image.clear();
395 std::cout << "Swapping and removing color channels." << std::endl;
396 zero_gb_image(image,width,height);
397 std::cout << "Saving: '08_zero_gb_image.ppm'." << std::endl;
398 save_image(image,width,height,"08_zero_gb_image.ppm");
400 image.clear();
403 r_zero_b_image(image,width,height);
404 std::cout << "Saving: '08_r_zero_b_image.ppm'." << std::endl;
405 save_image(image,width,height,"08_r_zero_b_image.ppm");
407 image.clear();
410 rg_zero_image(image,width,height);
411 std::cout << "Saving: '08_rg_zero_image.ppm'." << std::endl;
412 save_image(image,width,height,"08_rg_zero_image.ppm");
414 image.clear();
417 grb_image(image,width,height);
418 std::cout << "Saving: '08_grb_image.ppm'." << std::endl;
419 save_image(image,width,height,"08_grb_image.ppm");
421 image.clear();
424 bgr_image(image,width,height);
425 std::cout << "Saving: '08_bgr_image.ppm'." << std::endl;
426 save_image(image,width,height,"08_bgr_image.ppm");
428 image.clear();
431 rrb_image(image,width,height);
432 std::cout << "Saving: '08_rrb_image.ppm'." << std::endl << std::endl;
433 save_image(image,width,height,"08_rrb_image.ppm");
434
435 // Blend colors
436 std::vector<std::tuple<float, float, float>> blend1;
437 std::vector<std::tuple<float, float, float>> blend2;
438 read_image(blend1, width, height, "06_xor_texture.ppm");
439 read_image(blend2, width, height, "04_helloworld_square.ppm");
440 std::cout << "Blended two images." << std::endl;
441 blended_two_images(blend1,blend2,width,height,0.5);
442 std::cout << "Saving: '08_blended_two_images.ppm'." << std::endl << std::endl;
443 save_image(blend1,width,height,"08_blended_two_images.ppm");
444 blend1.clear(); blend2.clear();
445 read_image(blend1, width, height, "05_randomwalker.ppm");
446 read_image(blend2, width, height, "04_helloworld.ppm");
447 std::cout << "Blended two images2." << std::endl;
448 blended_two_images(blend1,blend2,width,height,0.2);
449 std::cout << "Saving: '08_blended_two_images2.ppm'." << std::endl << std::endl;
450 save_image(blend1,width,height,"08_blended_two_images2.ppm");
451
452 return 0;
453 }
09_lines.cpp - 7290 bytes.
1 // Compile: clang++ -std=c++17 09_lines.cpp -o 09_lines

3
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
10
12 {
14 }
15
17 {
19 }
20
21 void clear_image(std::vector<std::tuple<float, float, float>> &image, int width, int\
22 height)
23 {
26 image[get_index(x,y,width)]=std::make_tuple(1.0f, 1.0f, 1.0f);
27 }
28 }
29 }
30
31 std::tuple<float, float, float> h_to_rgb(float h)
32 {
33 float r=0.0f; float g=0.0f; float b=0.0f; float H=0.0f; float s=0.9f; float v=1.0f;
34 float f=0.0f; float p=0.0f; float q=0.0f; float t=0.0f;
35 int i=0;
36
37 H=h*360;
38
39 if (H == 360)
40 H = 0;
41 else
42 H = H / 60;
43
44 i = (int)std::trunc(H);
45 f = H - i;
46
47 p = v * (1.0 - s);
48 q = v * (1.0 - (s * f));
49 t = v * (1.0 - (s * (1.0 - f)));
50
51 switch (i)
52 {
53 case 0:
54 r = v;
55 g = t;
56 b = p;
57 break;
58 case 1:
59 r = q;
60 g = v;
61 b = p;
62 break;
63 case 2:
64 r = p;
65 g = v;
66 b = t;
67 break;
68 case 3:
69 r = p;
70 g = q;
71 b = v;
72 break;
73 case 4:
74 r = t;
75 g = p;
76 b = v;
77 break;
78 default:
79 r = v;
80 g = p;
81 b = q;
82 break;
83 }
84
86 }
87
88 void draw_line(std::vector<std::tuple<float, float, float>> &image, std::tuple<int, \
89 int, int, int> &coords, std::tuple<float,float,float> &color, int width, int height)
90 {
91 int x1=std::get<0>(coords); int y1=std::get<1>(coords); int x2=std::get<2>(coords);\
92 int y2=std::get<3>(coords);
93 int x, y, dx, dy, dx1, dy1, px, py, xe, ye, i;
94 dx = x2 - x1; dy = y2 - y1;
95 if (((x1 >= 0) && (x1 < width)) && ((x2 >= 0) && (x2 < width)) && ((y1 >= 0) && (y1\
96 < height)) && ((y2 >= 0) && (y2 < height))) {
97 if (dx == 0)
98 {
99 if (y2 < y1) std::swap(y1, y2);
100 for (y = y1; y <= y2; y++)
101 image[get_index(x1,y,width)]=color;
102 return;
103 }
104 if (dy == 0)
105 {
106 if (x2 < x1) std::swap(x1, x2);
107 for (x = x1; x <= x2; x++)
108 image[get_index(x,y1,width)]=color;
109 return;
110 }
111 dx1 = abs(dx); dy1 = abs(dy);
112 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
113 if (dy1 <= dx1)
114 {
115 if (dx >= 0)
116 {
117 x = x1; y = y1; xe = x2;
118 }
119 else
120 {
121 x = x2; y = y2; xe = x1;
122 }
124 for (i = 0; x<xe; i++)
125 {
126 x = x + 1;
127 if (px<0)
128 px = px + 2 * dy1;
129 else
130 {
131 if ((dx<0 && dy<0) || (dx>0 && dy>0)) y = y + 1; else y = y - 1;
132 px = px + 2 * (dy1 - dx1);
133 }
135 }
136 }
137 else
138 {
139 if (dy >= 0)
140 {
141 x = x1; y = y1; ye = y2;
142 }
143 else
144 {
145 x = x2; y = y2; ye = y1;
146 }
148 for (i = 0; y<ye; i++)
149 {
150 y = y + 1;
151 if (py <= 0)
152 py = py + 2 * dx1;
153 else
154 {
155 if ((dx<0 && dy<0) || (dx>0 && dy>0)) x = x + 1; else x = x - 1;
156 py = py + 2 * (dx1 - dy1);
157 }
159 }
160 }
161 }
162 }
163
164 int find_region(int x, int y, int width, int height)
165 {
166 int code=0;
167 if(y >= height)
168 code |= 1; //top
169 else if(y < 0)
170 code |= 2; //bottom
171 if(x >= width)
172 code |= 4; //right
173 else if (x < 0)
174 code |= 8; //left
175 return(code);
176 }
177
178 bool clip_line(std::tuple<int, int, int, int> &coords1, std::tuple<int, int, int, in\
179 t> &coords2, int width, int height)
180 {
181 int x1=std::get<0>(coords1); int y1=std::get<1>(coords1); int x2=std::get<2>(coords\
182 1); int y2=std::get<3>(coords1);
183 int x3=0; int y3=0; int x4=0; int y4=0;
184 int code1=0, code2=0, codeout=0;
185 bool accept = 0, done=0;
186 code1 = find_region(x1, y1, width, height); //the region outcodes for the endpoints
187 code2 = find_region(x2, y2, width, height);
188 do //In theory, this can never end up in an infinite loop, it'll always come in one\
189 of the trivial cases eventually

190 {
191 if(!(code1 | code2)) accept = done = 1; //accept because both endpoints are in sc\
192 reen or on the border, trivial accept
193 else if(code1 & code2) done = 1; //the line isn't visible on screen, trivial reject
194 else //if no trivial reject or accept, continue the loop
195 {
196 int x, y;
197 codeout = code1 ? code1 : code2;
198 if(codeout & 1) //top
199 {
200 x = x1 + (x2 - x1) * (height - y1) / (y2 - y1);
201 y = height - 1;
202 }
203 else if(codeout & 2) //bottom
204 {
205 x = x1 + (x2 - x1) * -y1 / (y2 - y1);
206 y = 0;
207 }
208 else if(codeout & 4) //right
209 {
210 y = y1 + (y2 - y1) * (width - x1) / (x2 - x1);
211 x = width - 1;
212 }
213 else //left
214 {
215 y = y1 + (y2 - y1) * -x1 / (x2 - x1);
216 x = 0;
217 }
218 if(codeout == code1) //first endpoint was clipped
219 {
220 x1 = x; y1 = y;
222 }
223 else //second endpoint was clipped
224 {
225 x2 = x; y2 = y;
227 }
228 }
229 }
230 while(done == 0);
231 if(accept)
232 {
233 x3 = x1;
234 x4 = x2;
235 y3 = y1;
236 y4 = y2;
237 coords2=std::make_tuple(x3,y3,x4,y4);
238 return 1;
239 }
240 else
241 {
242 x3 = x4 = y3 = y4 = 0;
244 return 0;
245 }
246 }
247
250 {
255 {
256 color=image[i];
259 }
260 out.close();
261 }
262
263 int main()
264 {
265 // Draw random lines (with line clipping).
267
269 std::mt19937 mt(rd());
270
271 std::uniform_int_distribution<> dist1(-100,740);
272 std::uniform_int_distribution<> dist2(-100,460);
273 std::uniform_real_distribution<float> dist3(0.0, 1.0);
274
275 std::tuple<float,float,float> color;

276 std::tuple<int, int, int, int> coords1;
278
279 int width=640;
280 int height=360;
281 int x1=0,y1=0,x2=0,y2=0;
282 float h=0.0f;
283
285 clear_image(image,width,height);
286
287 for (int i=0;i<15000;++i)
288 {
289 x1=dist1(mt);
290 y1=dist2(mt);
291 x2=dist1(mt);
292 y2=dist2(mt);
294 h=dist3(mt);
295 color=h_to_rgb(h);
296 if (clip_line(coords1,coords2,width,height)) {
297 draw_line(image,coords2,color,width,height);
298 }
299 }
300
301 save_image(image,width,height,"09_random_lines.ppm");
302
303 // Draw damped sine.
304 image.clear();
305 width=1920;height=640;
308
309 double numb_of_samples=1920.0;
310 int y=0; int ox=0; int oy=0;
311
312 std::tuple<float,float,float> black=std::make_tuple(0.0,0.0,0.0);
313 std::tuple<float,float,float> grey=std::make_tuple(0.5,0.5,0.5);
314 std::tuple<float,float,float> red=std::make_tuple(1.0,0.0,0.0);
315
316 coords1=std::make_tuple(0,height/2,width,height/2);
317 draw_line(image,coords1,red,width,height);
318
320 y=639-(319.0-(339.0*pow(1.0-(1.0/339.0),x))*sin(2*M_PI*x*(15.0/numb_of_samples)-1.\
321 0)+0);
322 if (x == 0) {ox=x;oy=y;}
323 coords1=std::make_tuple(x,y,ox,oy);
324 draw_line(image,coords1,black,width,height);
325 ox=x;oy=y;
326 }
327
329 y=319.0-(339.0*pow(1.0-(1.0/339.0),x));
330 if (x == 0) {ox=x;oy=y;}
331 coords1=std::make_tuple(x,y,ox,oy);
332 draw_line(image,coords1,grey,width,height);
333 ox=x;oy=y;
334 }
335
336 save_image(image,width,height,"09_damped_sine.ppm");
337
338 return 0;
339 }
09_angle_lines.cpp - 6576 bytes.
1 // Compile: clang++ -std=c++17 09_angle_lines.cpp -o 09_angle_lines

3
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
10
12 {
14 }
15
17 {
19 }
20
22 height)
23 {
27 }
28 }
29 }
30
33 {
37 dx = x2 - x1; dy = y2 - y1;
38 if (dx == 0)
39 {
40 if (y2 < y1) std::swap(y1, y2);
41 for (y = y1; y <= y2; y++)
43 return;
44 }
45 if (dy == 0)
46 {
47 if (x2 < x1) std::swap(x1, x2);
48 for (x = x1; x <= x2; x++)
50 return;
51 }
53 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
54 if (dy1 <= dx1)
55 {
56 if (dx >= 0)
57 {
58 x = x1; y = y1; xe = x2;
59 }
60 else
61 {
62 x = x2; y = y2; xe = x1;

63 }
65 for (i = 0; x<xe; i++)
66 {
67 x = x + 1;
68 if (px<0)
69 px = px + 2 * dy1;
70 else
71 {
73 px = px + 2 * (dy1 - dx1);
74 }
76 }
77 }
78 else
79 {
80 if (dy >= 0)
81 {
82 x = x1; y = y1; ye = y2;
83 }
84 else
85 {
86 x = x2; y = y2; ye = y1;
87 }
89 for (i = 0; y<ye; i++)
90 {
91 y = y + 1;
92 if (py <= 0)
93 py = py + 2 * dx1;
94 else
95 {
97 py = py + 2 * (dx1 - dy1);
98 }
100 }
101 }
102 }
103
105 {
106 int code=0;
107 if(y >= height)
108 code |= 1; //top
109 else if(y < 0)
111 if(x >= width)
113 else if (x < 0)
114 code |= 8; //left
115 return(code);
116 }
117
120 {
130 {
135 {
136 int x, y;
139 {
140 x = x1 + (x2 - x1) * (height - y1) / (y2 - y1);
141 y = height - 1;
142 }
144 {
145 x = x1 + (x2 - x1) * -y1 / (y2 - y1);
146 y = 0;
147 }

149 {
150 y = y1 + (y2 - y1) * (width - x1) / (x2 - x1);
151 x = width - 1;
152 }
153 else //left
154 {
155 y = y1 + (y2 - y1) * -x1 / (x2 - x1);
156 x = 0;
157 }
159 {
160 x1 = x; y1 = y;
162 }
164 {
165 x2 = x; y2 = y;
167 }
168 }
169 }
171 if(accept)
172 {
173 x3 = x1;
174 x4 = x2;
175 y3 = y1;
176 y4 = y2;
178 return 1;
179 }
180 else
181 {
182 x3 = x4 = y3 = y4 = 0;
184 return 0;
185 }
186 }
187
188 void get_angle_line(std::tuple<int, int, int, int> &coords,int x_cen,int y_cen,doubl\
189 e degrees,int length)
190 {
191 double angle = degrees * (M_PI / 180);

192 coords=std::make_tuple(x_cen,y_cen,int(double(x_cen) + cos(angle)*double(length)),i\
193 nt(double(y_cen) + sin(angle)*double(length)));
194 }
195
198 {
203 {
204 color=image[i];
207 }
208 out.close();
209 }
210
211 int main()
212 {
215
216
217 std::tuple<float,float,float> color=std::make_tuple(0.0,0.0,0.0);
218 std::tuple<int, int, int, int> coords;
219
220 int width=640;
221 int height=360;
222
225
226 int x_cen=width/2;
227 int y_cen=height/2;
228 int length=y_cen*0.8;
229 double degrees=0.0;
230
231 get_angle_line(coords,x_cen,y_cen,degrees,length);
232 if (clip_line(coords,coords,width,height)) {
233 draw_line(image,coords,color,width,height);
234 }
235 degrees=45.0;
239 }
240 degrees=90.0;
244 }
245 degrees=135.0;
249 }
250 degrees=180.0;
254 }
255 degrees=225.0;
259 }
260 degrees=270.0;
264 }
265 degrees=315.0;
269 }
270
271 save_image(image,width,height,"09_angle_lines.ppm");
272
273 return 0;
274 }
10_curved_dots.cpp - 7387 bytes.

1 // Compile: clang++ -std=c++20 10_curved_dots.cpp -o 10_curved_dots
2
5 #include <tuple>
6 #include <vector>
7 #include <random>
8 #include <cmath>
9
10 void linear_bezier_curves(std::tuple<int, int, int, int> &coords, int split, std::ve\
11 ctor<std::tuple<int,int>>& xy)
12 {
13 float t=0.0;
14 float delta=(float(1)/float(split));
15 int x=0;
16 int y=0;
17
18 for (int i=0;i<split;++i)
19 {
20 x = std::lerp(std::get<0>(coords),std::get<2>(coords),t);
21 y = std::lerp(std::get<1>(coords),std::get<3>(coords),t);
22 xy.push_back(std::make_tuple(x,y));
23 t+=delta;
24 }
25 }
26
27 void quadratic_bezier_curves(int px0, int py0, int px1, int py1, int px2, int py2, i\
28 nt split, std::vector<std::tuple<int,int>>& xy)
29 {
30 double t=0.0;
31 double delta=(double(1)/double(split));
32 int x=0;
33 int y=0;
34 int x1=0;
35 int y1=0;
36 int x2=0;
37 int y2=0;
39 {
40 x1 = std::lerp(px0,px1,t);
41 y1 = std::lerp(py0,py1,t);
44 x = std::lerp(x1,x2,t);
45 y = std::lerp(y1,y2,t);
47 t+=delta;
48 }
49 }
50
51 void cubic_bezier_curves(int px0, int py0, int px1, int py1, int px2, int py2, int p\
52 x3, int py3, int split, std::vector<std::tuple<int,int>>& xy)
53 {
54 float t=0.0;
56 int x=0;
57 int y=0;
58 int x1=0;
59 int y1=0;
60 int x2=0;
61 int y2=0;
62 int x3=0;
63 int y3=0;
64 int x4=0;
65 int y4=0;
66 int xx1=0;
67 int yy1=0;
68 int xx2=0;
69 int yy2=0;
71 {
76
81
82 xx1 = std::lerp(x1,x2,t);
83 yy1 = std::lerp(y1,y2,t);
86
87 x = std::lerp(xx1,xx2,t);
88 y = std::lerp(yy1,yy2,t);
90 t+=delta;
91 }
92 }
93
95 {
97 }
98
100 {
102 }
103
105 height)
106 {
110 }
111 }
112 }
113
116 {
120 dx = x2 - x1; dy = y2 - y1;
121 if (dx == 0)
122 {
123 if (y2 < y1) std::swap(y1, y2);
124 for (y = y1; y <= y2; y++)
126 return;
127 }
128 if (dy == 0)
129 {
130 if (x2 < x1) std::swap(x1, x2);
131 for (x = x1; x <= x2; x++)
133 return;
134 }
136 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
137 if (dy1 <= dx1)
138 {
139 if (dx >= 0)
140 {
141 x = x1; y = y1; xe = x2;
142 }
143 else
144 {
145 x = x2; y = y2; xe = x1;
146 }
148 for (i = 0; x<xe; i++)
149 {
150 x = x + 1;
151 if (px<0)
152 px = px + 2 * dy1;
153 else
154 {
156 px = px + 2 * (dy1 - dx1);
157 }
159 }
160 }
161 else
162 {
163 if (dy >= 0)
164 {
165 x = x1; y = y1; ye = y2;
166 }
167 else
168 {
169 x = x2; y = y2; ye = y1;
170 }
172 for (i = 0; y<ye; i++)

173 {
174 y = y + 1;
175 if (py <= 0)
176 py = py + 2 * dx1;
177 else
178 {
180 py = py + 2 * (dx1 - dy1);
181 }
183 }
184 }
185 }
186
187 void draw_xy_dots(std::vector<std::tuple<float, float, float>> &image,std::tuple<flo\
188 at,float,float> &color,std::vector<std::tuple<int,int>>& xy,int width,int height)
189 {
190 for (auto& pt : xy)
191 {
192 image[get_index(std::get<0>(pt),std::get<1>(pt),width)]=color;
193 }
194 }
195
196 void draw_marker(int x, int y, std::vector<std::tuple<float, float, float>> &image, \
197 std::tuple<float,float,float> &color, int width, int height)
198 {
199 image[get_index(x-1,y-1,width)]=color;
200 image[get_index(x,y-1,width)]=color;
201 image[get_index(x+1,y-1,width)]=color;
202 image[get_index(x+1,y,width)]=color;
203 image[get_index(x+1,y+1,width)]=color;
204 image[get_index(x,y+1,width)]=color;
205 image[get_index(x-1,y+1,width)]=color;
206 image[get_index(x-1,y,width)]=color;
207
208 color=std::make_tuple(1.0f, 1.0f, 1.0f);
210 }
211
214 {

219 {
220 color=image[i];
223 }
224 out.close();
225 }
226
227 int main()
228 {
229 int width=640;
230 int height=360;
233
236
237 std::vector<std::tuple<int,int>> xy;
239
240 // Draw dots in a line with Bezier.
241 color=std::make_tuple(0.9296875, 0.9296875, 0.9296875);
242 coords=std::make_tuple(20,90,300,90);
244 linear_bezier_curves(coords,10,xy);
246 draw_xy_dots(image,color,xy,width,height);
247 xy.clear();
249 draw_marker(20,90,image,color,width,height);
252
253 // Draw dots in a curve 1.
259 quadratic_bezier_curves(340,90,480,2,620,90,10,xy);
262 xy.clear();
269
270 // Draw dots in a curve 2.
276 cubic_bezier_curves(200,270,293,182,386,357,480,270,10,xy);
279 xy.clear();
288
289 save_image(image,width,height,"10_curved_dots.ppm");
290
291 return 0;
292 }
10_curved_lines.cpp - 8643 bytes.

1 // Compile: clang++ -std=c++20 10_curved_lines.cpp -o 10_curved_lines
2
5 #include <tuple>
6 #include <vector>
7 #include <random>
8 #include <cmath>
9
10 void linear_bezier_curves(std::tuple<int, int, int, int> &coords, int split, std::ve\
11 ctor<std::tuple<int,int>>& xy)
12 {
13 float t=0.0;
15 int x=0;
16 int y=0;
17
19 {
20 x = std::lerp(std::get<0>(coords),std::get<2>(coords),t);
21 y = std::lerp(std::get<1>(coords),std::get<3>(coords),t);
23 t+=delta;
24 }
25 }
26
27 void quadratic_bezier_curves(int px0, int py0, int px1, int py1, int px2, int py2, i\
28 nt split, std::vector<std::tuple<int,int>>& xy)
29 {
30 double t=0.0;
32 int x=0;
33 int y=0;
34 int x1=0;
35 int y1=0;
36 int x2=0;
37 int y2=0;
39 {
47 t+=delta;
48 }
49 }
50
51 void cubic_bezier_curves(int px0, int py0, int px1, int py1, int px2, int py2, int p\
52 x3, int py3, int split, std::vector<std::tuple<int,int>>& xy)
53 {
54 float t=0.0;
56 int x=0;
57 int y=0;
58 int x1=0;
59 int y1=0;
60 int x2=0;
61 int y2=0;
62 int x3=0;
63 int y3=0;
64 int x4=0;
65 int y4=0;
66 int xx1=0;
67 int yy1=0;
68 int xx2=0;
69 int yy2=0;
71 {
76
81
86
90 t+=delta;
91 }
92 }
93
95 {
97 }
98
100 {
102 }
103
105 height)
106 {
110 }
111 }
112 }
113
116 {
120 dx = x2 - x1; dy = y2 - y1;
121 if (dx == 0)
122 {
123 if (y2 < y1) std::swap(y1, y2);
124 for (y = y1; y <= y2; y++)
126 return;
127 }
128 if (dy == 0)
129 {
130 if (x2 < x1) std::swap(x1, x2);
131 for (x = x1; x <= x2; x++)
133 return;
134 }
136 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
137 if (dy1 <= dx1)
138 {
139 if (dx >= 0)
140 {
141 x = x1; y = y1; xe = x2;
142 }
143 else
144 {
145 x = x2; y = y2; xe = x1;
146 }
148 for (i = 0; x<xe; i++)
149 {
150 x = x + 1;
151 if (px<0)
152 px = px + 2 * dy1;
153 else
154 {
156 px = px + 2 * (dy1 - dx1);
157 }
159 }
160 }
161 else
162 {
163 if (dy >= 0)
164 {
165 x = x1; y = y1; ye = y2;
166 }
167 else
168 {
169 x = x2; y = y2; ye = y1;
170 }
172 for (i = 0; y<ye; i++)

173 {
174 y = y + 1;
175 if (py <= 0)
176 py = py + 2 * dx1;
177 else
178 {
180 py = py + 2 * (dx1 - dy1);
181 }
183 }
184 }
185 }
186
187 void draw_xy_line(std::vector<std::tuple<float, float, float>> &image,std::tuple<flo\
188 at,float,float> &color,std::vector<std::tuple<int,int>>& xy,int width,int height,int
189 x_stop,int y_stop)
190 {
191 std::tuple<int, int> temp=xy[0];
192 std::tuple<int, int> store;
193 store=std::make_tuple(x_stop,y_stop);
194 xy.push_back(store);
195 std::vector<std::tuple<int,int,int,int>> xyxy;
196 for (int i=1;i<xy.size();++i)
197 {
198 store=xy[i];
199 xyxy.push_back(std::make_tuple(std::get<0>(temp),std::get<1>(temp),std::get<0>(sto\
200 re),std::get<1>(store)));
201 temp=xy[i];
202 }
203
204 for (auto& li : xyxy)
205 {
206 draw_line(image,li,color,width,height);
207 }
208 }
209
210 void draw_xy_dots(std::vector<std::tuple<float, float, float>> &image,std::tuple<flo\
211 at,float,float> &color,std::vector<std::tuple<int,int>>& xy,int width,int height)
212 {
214 {
215 image[get_index(std::get<0>(pt),std::get<1>(pt),width)]=color;
216 }
217 }
218
219 void draw_marker(int x, int y, std::vector<std::tuple<float, float, float>> &image, \
220 std::tuple<float,float,float> &color, int width, int height)
221 {
222 image[get_index(x-1,y-1,width)]=color;
223 image[get_index(x,y-1,width)]=color;
224 image[get_index(x+1,y-1,width)]=color;
225 image[get_index(x+1,y,width)]=color;
226 image[get_index(x+1,y+1,width)]=color;
227 image[get_index(x,y+1,width)]=color;
228 image[get_index(x-1,y+1,width)]=color;
229 image[get_index(x-1,y,width)]=color;
230
231 color=std::make_tuple(1.0f, 1.0f, 1.0f);
233 }
234
237 {
242 {
243 color=image[i];
246 }
247 out.close();
248 }
249
250 int main()
251 {
252 int width=640;
253 int height=360;
256
259
262
263 // Draw a line with Bezier.
269 draw_xy_line(image,color,xy,width,height,300,90);
270 xy.clear();
275 xy.clear();
280
281 // Draw line as a curve 1.
290 xy.clear();
294 xy.clear();
301
302 // Draw line as a curve 2.
303 xy.clear();
312 xy.clear();
316 xy.clear();
325
326 save_image(image,width,height,"10_curved_lines.ppm");
327
328 return 0;
329 }
11_rectangles.cpp - 4120 bytes.
1 // Compile: clang++ -std=c++17 11_rectangles.cpp -o 11_rectangles

2
5 #include <tuple>
6 #include <vector>
7 #include <random>
8 #include <cmath>
9
11 {
13 }
14
16 {
18 }
19
21 height)
22 {
26 }
27 }
28 }
29
32 {
36 dx = x2 - x1; dy = y2 - y1;
37 if (dx == 0)
38 {
39 if (y2 < y1) std::swap(y1, y2);
40 for (y = y1; y <= y2; y++)
42 return;
43 }
44 if (dy == 0)
45 {
46 if (x2 < x1) std::swap(x1, x2);
47 for (x = x1; x <= x2; x++)
49 return;
50 }
52 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
53 if (dy1 <= dx1)
54 {
55 if (dx >= 0)
56 {
57 x = x1; y = y1; xe = x2;
58 }
59 else
60 {
61 x = x2; y = y2; xe = x1;
62 }
64 for (i = 0; x<xe; i++)
65 {
66 x = x + 1;
67 if (px<0)
68 px = px + 2 * dy1;
69 else
70 {
72 px = px + 2 * (dy1 - dx1);
73 }
75 }
76 }
77 else
78 {
79 if (dy >= 0)
80 {
81 x = x1; y = y1; ye = y2;
82 }
83 else
84 {
85 x = x2; y = y2; ye = y1;
86 }
88 for (i = 0; y<ye; i++)
89 {
90 y = y + 1;
91 if (py <= 0)
92 py = py + 2 * dx1;
93 else
94 {
96 py = py + 2 * (dx1 - dy1);
97 }
99 }
100 }
101 }
102
103 void draw_rect(int x, int y, int w, int h, std::vector<std::tuple<float, float, floa\
104 t>> &image, std::tuple<float,float,float> &color, int width, int height)
105 {
106 w=w-1;
107 h=h-1;
108 std::tuple<int, int, int, int> coords=std::make_tuple(x, y, x+w, y);
109 draw_line(image, coords, color, width, height);
110 coords=std::make_tuple(x+w, y, x+w, y+h);
112 coords=std::make_tuple(x+w, y+h, x, y+h);
114 coords=std::make_tuple(x, y+h, x, y);
116 }
117
118 void draw_filled_rect(int x, int y, int w, int h, std::vector<std::tuple<float, floa\
119 t, float>> &image, std::tuple<float,float,float> &color, int width, int height)
120 {
121 int x2 = x + w;
122 int y2 = y + h;
123
124 if (x < 0) {x = 0;}
125 if (x >= width) {x = width;}
126 if (y < 0) {y = 0;}
127 if (y >= height) {y = height;}
128
129 if (x2 < 0) {x2 = 0;}
130 if (x2 >= width) {x2 = width;}
131 if (y2 < 0) {y2 = 0;}
132 if (y2 >= height) {y2 = height;}
133
134 for (int i = y; i < y2; i++) {
135 for (int j = x; j < x2; j++) {
136 image[get_index(j,i,width)]=color;
137 }
138 }
139 }
140

143 {
148 {
149 color=image[i];
152 }
153 out.close();
154 }
155
156 int main()
157 {
158 int width=640;
159 int height=360;
160 int x1=0; int y=0; int wh=0; int x2=0;
161
162 wh=(height/2)*0.8;
163 x1=(width-(wh*3))/2;
164 y=(height-wh)/2;
165 x2=width-x1-wh;
166
168 std::tuple<float,float,float> color=std::make_tuple(0.0f,0.0f,0.0f);
169
172
173 draw_rect(x1,y,wh,wh,image,color,width,height);
174 draw_filled_rect(x2,y,wh,wh,image,color,width,height);
175
176 save_image(image,width,height,"11_rectangles.ppm");
177
178 return 0;
179 }
11_rectangles_from_file.cpp - 4451 bytes.

1 // Compile: clang++ -std=c++17 11_rectangles_from_file.cpp -o 11_rectangles_from_file
2
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
10
12 {
18 return true;
19 else
20 return false;
21 }
22
24 {
26 }
27
29 {
31 }
32
34 at,float,float> &colorRGB, int width, int height)
35 {
38 image[get_index(x,y,width)]=colorRGB;
39 }
40 }
41 }
42
43 std::tuple<int,int,float,float,float> parse_bginfo_line(const std::string str, int &\

44 width, int &height)
45 {
46 size_t start;
47 size_t end = 0;
49
51 {
54 }
55
56 width=stoi(out[1]);
57 height=stoi(out[2]);
58 float rf=stof(out[3]);
59 float gf=stof(out[4]);
60 float bf=stof(out[5]);
61
62 return std::make_tuple(width,height,rf,gf,bf);
63 }
64
65 std::tuple<int,int,int,int,float,float,float,float> parse_rect_line(const std::strin\
66 g str)
67 {
68 size_t start;
69 size_t end = 0;
71
73 {
76 }
77
78 int x1=stoi(out[1]);
79 int y1=stoi(out[2]);
85 float af=stof(out[8]);
86
87 return std::make_tuple(x1,y1,x2,y2,rf,gf,bf,af);
88 }
89
90 std::tuple<float,float,float> blend_colors(std::tuple<float,float,float> &colorBGRGB\
91 , std::tuple<float,float,float,float> &colorRGBA)
92 {
94 r = (std::get<0>(colorRGBA) * std::get<3>(colorRGBA)) + (std::get<0>(colorBGRGB) * \
95 (1.0 - std::get<3>(colorRGBA)));
96 g = (std::get<1>(colorRGBA) * std::get<3>(colorRGBA)) + (std::get<1>(colorBGRGB) * \
98 b = (std::get<2>(colorRGBA) * std::get<3>(colorRGBA)) + (std::get<2>(colorBGRGB) * \
100
102 }
103
104 void draw_filled_rect(int x1,int y1,int x2,int y2, std::vector<std::tuple<float, flo\
105 at, float>> &image, std::tuple<float,float,float,float> &colorRGBA, int width, int h
106 eight)
107 {
108 for (int i = y1; i < y2; i++) {
109 for (int j = x1; j < x2; j++) {
110 image[get_index(j,i,width)]=blend_colors(image[get_index(j,i,width)],colorRG
111 }
112 }
113 }
114
117 {
122 {
123 color=image[i];
126 }
127 out.close();
128 }
129
130 int main()
131 {
132 std::ifstream infile("11_squint_with_your_eyes.txt");
134 std::tuple<int,int,int,int,float,float,float,float> rect;
135 std::tuple<int,int,float,float,float> bginfo;
136 std::tuple<float,float,float> colorBGRGB;
137 std::tuple<float,float,float,float> colorRGBA;
138 int width,height,x1,y1,x2,y2;
139 float rf,gf,bf,af;
140 float bg_rf,bg_gf,bg_bf;
143 {
144 if (startsWithCaseInsensitive(line,"r")) {
145 rect=parse_rect_line(line);
146 std::tie(x1,y1,x2,y2,rf,gf,bf,af) = rect;
147 colorRGBA=std::make_tuple(rf,gf,bf,af);
148 draw_filled_rect(x1,y1,x2,y2,image,colorRGBA,width,height);
149 }
150
151 if (startsWithCaseInsensitive(line,"b")) {
152 bginfo=parse_bginfo_line(line,width,height);
153 std::tie(width,height,bg_rf,bg_gf,bg_bf) = bginfo;
155 colorBGRGB=std::make_tuple(bg_rf,bg_gf,bg_bf);
156 clear_image(image,colorBGRGB,width,height);
157 }
158 }
159 infile.close();
160
161 save_image(image,width,height,"11_squint_with_your_eyes.ppm");
162
163 return 0;
164 }
11_squint_with_your_eyes.txt - 26913 bytes.

1 b 540 720 0.211765 0.172549 0.152941
2 r 211 190 333 441 0.796078 0.517647 0.305882 0.501961
3 r 58 398 200 719 0.47451 0.231373 0.239216 0.501961
4 r 253 601 393 719 0.396078 0.368627 0.392157 0.501961
5 r 278 326 348 479 0.737255 0.423529 0.329412 0.501961
6 r 377 0 539 692 0.0117647 0.0627451 0.0784314 0.501961
7 r 93 318 142 506 0.380392 0.423529 0.419608 0.501961
8 r 211 413 265 595 0.054902 0.0470588 0.0392157 0.501961
9 r 303 39 431 301 0.0588235 0.0784314 0.0470588 0.501961
10 r 132 107 183 373 0 0.0235294 0 0.501961
11 r 186 170 320 271 0.552941 0.423529 0.211765 0.501961
12 r 37 562 144 719 0.447059 0.0705882 0.0745098 0.501961
13 r 180 76 371 146 0 0.0156863 0 0.501961
14 r 268 550 319 585 0.631373 0.396078 0.25098 0.501961
15 r 198 352 302 379 0.756863 0.521569 0.356863 0.501961
16 r 328 595 405 692 0.392157 0.317647 0.32549 0.501961
17 r 245 467 291 544 0 0.00784314 0 0.501961
18 r 166 396 228 440 0.0117647 0.0901961 0.0627451 0.501961
19 r 188 276 252 317 0.286275 0.152941 0.0745098 0.501961
20 r 250 372 339 451 0.533333 0.305882 0.294118 0.501961
21 r 228 196 286 243 0.643137 0.588235 0.364706 0.501961
22 r 114 390 162 473 0.407843 0.403922 0.384314 0.501961
23 r 273 317 297 372 0.929412 0.603922 0.352941 0.501961
24 r 0 202 76 534 0.0941176 0.172549 0.168627 0.501961
25 r 183 427 202 633 0.317647 0.372549 0.372549 0.501961
26 r 241 587 315 672 0.196078 0.219608 0.231373 0.501961
27 r 97 165 131 294 0 0.054902 0.027451 0.501961
28 r 287 250 383 303 0.266667 0.172549 0.12549 0.501961
29 r 213 144 306 198 0.4 0.211765 0.0823529 0.501961
30 r 395 211 458 461 0.00392157 0.0156863 0.00784314 0.501961
31 r 159 94 210 192 0.0509804 0.0705882 0.0431373 0.501961
32 r 179 621 249 679 0.415686 0.2 0.203922 0.501961
33 r 289 454 386 484 0.537255 0.329412 0.152941 0.501961
34 r 121 307 141 398 0.372549 0.364706 0.356863 0.501961
35 r 248 697 294 719 0.603922 0.196078 0.2 0.501961
36 r 398 628 408 699 0.486275 0.027451 0.0313726 0.501961
37 r 111 548 154 631 0.231373 0.133333 0.133333 0.501961
38 r 327 293 387 353 0.215686 0.156863 0.117647 0.501961
39 r 156 329 179 404 0.00392157 0.0196078 0.00784314 0.501961
40 r 0 0 116 219 0.180392 0.290196 0.294118 0.501961
41 r 223 372 261 400 0.733333 0.505882 0.317647 0.501961
42 r 241 662 269 688 0.0196078 0.0901961 0.0823529 0.501961
43 r 360 345 406 424 0.0901961 0.0745098 0.054902 0.501961

44 r 4 279 50 622 0.137255 0.152941 0.141176 0.501961
45 r 287 643 337 702 0.34902 0.380392 0.388235 0.501961
46 r 262 352 275 390 0.321569 0.207843 0.172549 0.501961
47 r 194 266 230 353 0.313726 0.219608 0.156863 0.501961
48 r 307 418 335 480 0.686275 0.403922 0.341176 0.501961
49 r 202 479 232 548 0.305882 0.196078 0.211765 0.501961
50 r 284 355 300 364 1 0.890196 0.74902 0.501961
51 r 299 477 365 560 0.345098 0.184314 0.0941176 0.501961
52 r 278 622 301 650 0.054902 0.0901961 0.0901961 0.501961
53 r 42 598 72 718 0.501961 0.105882 0.109804 0.501961
54 r 197 681 239 719 0.239216 0.027451 0.027451 0.501961
55 r 77 189 100 365 0.0980392 0.141176 0.137255 0.501961
56 r 65 522 108 635 0.454902 0.109804 0.105882 0.501961
57 r 198 421 238 450 0.027451 0.0352941 0.0117647 0.501961
58 r 335 587 381 655 0.298039 0.356863 0.368627 0.501961
59 r 353 249 364 362 0 0.0705882 0.0941176 0.501961
60 r 346 373 364 543 0.317647 0.196078 0.129412 0.501961
61 r 117 0 539 81 0.117647 0.188235 0.184314 0.501961
62 r 408 693 539 719 0.0745098 0.0509804 0.101961 0.501961
63 r 287 205 331 233 0.537255 0.411765 0.258824 0.501961
64 r 234 407 326 423 0.498039 0.262745 0.262745 0.501961
65 r 88 0 162 128 0.156863 0.227451 0.223529 0.501961
66 r 285 288 326 331 0.509804 0.317647 0.223529 0.501961
67 r 329 136 392 203 0.0313726 0.0431373 0.0235294 0.501961
68 r 73 384 109 516 0.290196 0.290196 0.286275 0.501961
69 r 284 584 315 600 0.360784 0.384314 0.403922 0.501961
70 r 369 277 377 328 0.517647 0.290196 0.152941 0.501961
71 r 396 435 520 632 0.0823529 0.0901961 0.129412 0.501961
72 r 199 302 236 311 0.619608 0.403922 0.301961 0.501961
73 r 274 378 291 399 0.27451 0.2 0.113725 0.501961
74 r 328 679 410 719 0.356863 0.203922 0.207843 0.501961
75 r 268 293 280 361 0.756863 0.482353 0.309804 0.501961
76 r 105 152 161 266 0.0705882 0.0705882 0.0392157 0.501961
77 r 29 666 49 719 0.482353 0.0784314 0.0862745 0.501961
78 r 196 219 298 258 0.541176 0.45098 0.239216 0.501961
79 r 269 439 353 459 0.513726 0.384314 0.235294 0.501961
80 r 350 540 401 578 0.0784314 0.105882 0.160784 0.501961
81 r 162 680 220 707 0.447059 0.168627 0.164706 0.501961
82 r 263 644 281 663 0.0156863 0.0666667 0.0705882 0.501961
83 r 216 695 240 719 0 0.0862745 0.0666667 0.501961
84 r 302 598 320 621 0.0313726 0.0980392 0.121569 0.501961
85 r 240 612 254 668 0.376471 0.305882 0.309804 0.501961
86 r 225 438 258 495 0.054902 0.0627451 0.0313726 0.501961

87 r 297 422 331 435 0.807843 0.384314 0.505882 0.501961
88 r 241 194 278 226 0.654902 0.564706 0.376471 0.501961
89 r 168 278 229 290 0.141176 0.0862745 0.0352941 0.501961
90 r 163 407 193 475 0.254902 0.266667 0.25098 0.501961
91 r 197 165 213 274 0.466667 0.290196 0.172549 0.501961
92 r 314 615 352 662 0.317647 0.388235 0.4 0.501961
93 r 244 475 299 540 0.0901961 0.0705882 0.0431373 0.501961
94 r 321 247 335 268 0.505882 0.352941 0.219608 0.501961
95 r 70 465 124 525 0.384314 0.235294 0.231373 0.501961
96 r 316 573 347 597 0.0470588 0.12549 0.180392 0.501961
97 r 384 0 539 179 0.14902 0.168627 0.14902 0.501961
98 r 324 343 354 374 0.454902 0.341176 0.262745 0.501961
99 r 180 562 193 719 0.4 0.286275 0.282353 0.501961
100 r 216 627 224 653 0.0627451 0.0235294 0 0.501961
101 r 280 261 313 293 0.345098 0.188235 0.0941176 0.501961
102 r 314 147 409 180 0.0509804 0.0666667 0.0431373 0.501961
103 r 306 242 321 263 0.156863 0.101961 0.0784314 0.501961
104 r 354 447 394 470 0.219608 0.12549 0.0901961 0.501961
105 r 317 525 356 551 0.403922 0.262745 0.164706 0.501961
106 r 311 398 348 411 0.376471 0.152941 0.247059 0.501961
107 r 233 622 240 641 0.643137 0.0196078 0.0196078 0.501961
108 r 232 676 256 701 0.0352941 0.0901961 0.0823529 0.501961
109 r 139 316 216 328 0.0901961 0.0784314 0.0431373 0.501961
110 r 358 197 368 251 0.329412 0.164706 0.0823529 0.501961
111 r 97 370 151 412 0.352941 0.345098 0.341176 0.501961
112 r 311 373 335 394 0.705882 0.490196 0.337255 0.501961
113 r 43 100 81 208 0.266667 0.262745 0.254902 0.501961
114 r 216 68 304 129 0.0431373 0.0705882 0.0509804 0.501961
115 r 284 557 304 575 0.639216 0.380392 0.192157 0.501961
116 r 212 577 272 600 0.12549 0.105882 0.0980392 0.501961
117 r 195 350 265 364 0.556863 0.364706 0.235294 0.501961
118 r 256 604 271 648 0.360784 0.32549 0.32549 0.501961
119 r 148 104 215 162 0.0666667 0.0823529 0.054902 0.501961
120 r 231 317 239 329 0.568627 0.572549 0.607843 0.501961
121 r 221 646 235 682 0.478431 0.176471 0.184314 0.501961
122 r 287 446 314 450 0.231373 0.152941 0.0862745 0.501961
123 r 130 269 142 368 0.231373 0.223529 0.207843 0.501961
124 r 282 705 291 719 0.713726 0.0588235 0.0588235 0.501961
125 r 128 404 136 538 0.27451 0.341176 0.341176 0.501961
126 r 240 396 278 422 0.584314 0.403922 0.254902 0.501961
127 r 285 321 303 345 0.713726 0.364706 0.109804 0.501961
128 r 110 590 122 660 0.196078 0.12549 0.12549 0.501961
129 r 245 274 292 296 0.560784 0.356863 0.160784 0.501961

130 r 206 326 233 339 0.423529 0.403922 0.337255 0.501961
131 r 196 390 214 438 0.0823529 0.0588235 0.0235294 0.501961
132 r 363 417 369 446 0.447059 0.305882 0.215686 0.501961
133 r 370 386 473 434 0.0666667 0.0705882 0.0627451 0.501961
134 r 207 380 230 402 0.513726 0.290196 0.184314 0.501961
135 r 260 681 286 698 0.439216 0.32549 0.321569 0.501961
136 r 276 163 315 200 0.372549 0.215686 0.109804 0.501961
137 r 170 368 180 429 0.0588235 0.0666667 0.0431373 0.501961
138 r 372 508 450 603 0.105882 0.117647 0.145098 0.501961
139 r 57 398 71 472 0.0941176 0.152941 0.129412 0.501961
140 r 386 611 399 661 0.384314 0.172549 0.160784 0.501961
141 r 286 452 340 472 0.603922 0.419608 0.219608 0.501961
142 r 362 709 373 719 0.647059 0.141176 0.133333 0.501961
143 r 265 548 276 574 0.298039 0.313726 0.360784 0.501961
144 r 474 81 539 386 0.141176 0.176471 0.160784 0.501961
145 r 290 485 380 515 0.243137 0.137255 0.0823529 0.501961
146 r 445 181 539 246 0.141176 0.164706 0.14902 0.501961
147 r 48 556 57 624 0.305882 0.235294 0.231373 0.501961
148 r 277 223 312 246 0.470588 0.447059 0.282353 0.501961
149 r 209 459 219 558 0.286275 0.188235 0.188235 0.501961
150 r 69 706 80 719 0.258824 0.329412 0.309804 0.501961
151 r 294 614 307 632 0.0431373 0.0784314 0.0980392 0.501961
152 r 259 462 281 524 0.0352941 0.0509804 0.027451 0.501961
153 r 414 263 470 336 0.0196078 0.0352941 0.027451 0.501961
154 r 328 162 358 210 0.145098 0.133333 0.0901961 0.501961
155 r 167 663 180 719 0.490196 0.14902 0.145098 0.501961
156 r 208 647 215 677 0.211765 0.027451 0.00784314 0.501961
157 r 275 314 282 332 0.854902 0.647059 0.521569 0.501961
158 r 283 411 320 422 0.435294 0.160784 0.258824 0.501961
159 r 175 304 192 357 0.133333 0.160784 0.141176 0.501961
160 r 267 597 288 606 0.117647 0.0862745 0.0627451 0.501961
161 r 318 327 328 347 0.678431 0.517647 0.427451 0.501961
162 r 0 623 25 719 0.117647 0.145098 0.137255 0.501961
163 r 324 410 340 426 0.717647 0.396078 0.47451 0.501961
164 r 140 395 163 459 0.403922 0.333333 0.313726 0.501961
165 r 356 578 377 608 0.247059 0.282353 0.290196 0.501961
166 r 408 581 539 697 0.12549 0.101961 0.133333 0.501961
167 r 361 357 374 405 0.0196078 0.0784314 0.0901961 0.501961
168 r 218 316 223 320 0.643137 0.690196 0.701961 0.501961
169 r 327 276 333 279 0.603922 0.639216 0.65098 0.501961
170 r 259 0 376 75 0.105882 0.133333 0.121569 0.501961
171 r 207 313 237 316 0.0941176 0.0705882 0.0352941 0.501961
172 r 191 287 247 302 0.32549 0.172549 0.0980392 0.501961

173 r 253 297 261 354 0.454902 0.243137 0.101961 0.501961
174 r 394 402 406 435 0.215686 0.145098 0.109804 0.501961
175 r 190 442 200 588 0.309804 0.341176 0.341176 0.501961
176 r 263 616 283 632 0.352941 0.341176 0.352941 0.501961
177 r 365 31 495 125 0.129412 0.145098 0.129412 0.501961
178 r 445 427 485 465 0.121569 0.14902 0.156863 0.501961
179 r 139 496 161 570 0.329412 0.113725 0.12549 0.501961
180 r 96 98 136 171 0.137255 0.188235 0.184314 0.501961
181 r 294 542 337 566 0.388235 0.223529 0.129412 0.501961
182 r 244 142 291 178 0.376471 0.227451 0.101961 0.501961
183 r 334 312 345 358 0.403922 0.278431 0.192157 0.501961
184 r 127 605 146 647 0.431373 0.0941176 0.0901961 0.501961
185 r 253 421 284 443 0.447059 0.27451 0.215686 0.501961
186 r 402 663 408 694 0.52549 0.0313726 0.027451 0.501961
187 r 342 217 359 307 0.0666667 0.129412 0.133333 0.501961
188 r 0 275 77 430 0.145098 0.160784 0.14902 0.501961
189 r 161 204 170 281 0.235294 0.129412 0.0745098 0.501961
190 r 111 457 125 519 0.490196 0.247059 0.243137 0.501961
191 r 213 138 256 156 0.176471 0.14902 0.0784314 0.501961
192 r 294 255 312 270 0.192157 0.12549 0.0862745 0.501961
193 r 82 350 100 383 0.231373 0.239216 0.235294 0.501961
194 r 274 581 298 584 0.737255 0.403922 0.2 0.501961
195 r 309 579 317 591 0.278431 0.431373 0.478431 0.501961
196 r 101 0 191 88 0.168627 0.219608 0.215686 0.501961
197 r 310 449 331 483 0.611765 0.4 0.243137 0.501961
198 r 125 146 192 195 0.0745098 0.0823529 0.0509804 0.501961
199 r 193 370 199 403 0.0666667 0.0784314 0.0352941 0.501961
200 r 82 366 89 548 0.266667 0.258824 0.247059 0.501961
201 r 203 159 227 195 0.32549 0.2 0.117647 0.501961
202 r 297 78 364 152 0.0431373 0.0666667 0.054902 0.501961
203 r 137 652 170 719 0.329412 0.164706 0.156863 0.501961
204 r 223 257 280 281 0.501961 0.372549 0.176471 0.501961
205 r 309 270 320 277 0.533333 0.376471 0.270588 0.501961
206 r 1 354 43 639 0.160784 0.160784 0.14902 0.501961
207 r 207 584 235 629 0.215686 0.121569 0.109804 0.501961
208 r 280 354 291 369 0.921569 0.678431 0.498039 0.501961
209 r 118 561 132 614 0.2 0.172549 0.184314 0.501961
210 r 144 276 165 375 0.0588235 0.0470588 0.0156863 0.501961
211 r 204 359 250 384 0.643137 0.439216 0.286275 0.501961
212 r 98 288 121 331 0.160784 0.188235 0.180392 0.501961
213 r 291 434 335 443 0.6 0.231373 0.313726 0.501961
214 r 271 377 302 389 0.380392 0.243137 0.156863 0.501961
215 r 215 661 229 686 0.360784 0.258824 0.266667 0.501961

216 r 201 660 211 717 0.368627 0.0745098 0.0705882 0.501961
217 r 291 641 318 708 0.329412 0.333333 0.341176 0.501961
218 r 185 203 197 275 0.439216 0.294118 0.180392 0.501961
219 r 293 594 307 605 0.364706 0.364706 0.372549 0.501961
220 r 309 184 324 211 0.431373 0.231373 0.0901961 0.501961
221 r 404 576 437 645 0.0784314 0.121569 0.152941 0.501961
222 r 238 708 275 719 0.352941 0.262745 0.258824 0.501961
223 r 348 271 354 352 0.117647 0.184314 0.215686 0.501961
224 r 518 582 533 606 0.262745 0.0980392 0.105882 0.501961
225 r 372 171 417 264 0.054902 0.0509804 0.0431373 0.501961
226 r 385 430 437 457 0.0352941 0.0509804 0.0392157 0.501961
227 r 312 290 321 296 0.486275 0.454902 0.466667 0.501961
228 r 271 691 284 711 0.607843 0.2 0.203922 0.501961
229 r 312 593 324 607 0.027451 0.0823529 0.121569 0.501961
230 r 155 465 178 523 0.286275 0.156863 0.164706 0.501961
231 r 24 689 70 719 0.403922 0.137255 0.133333 0.501961
232 r 319 275 328 291 0.172549 0.0823529 0 0.501961
233 r 100 646 112 718 0.290196 0.109804 0.117647 0.501961
234 r 358 649 400 710 0.290196 0.239216 0.239216 0.501961
235 r 87 265 124 302 0.105882 0.0980392 0.0705882 0.501961
236 r 448 316 503 376 0.105882 0.12549 0.0980392 0.501961
237 r 185 394 193 491 0.262745 0.290196 0.27451 0.501961
238 r 265 287 276 353 0.639216 0.419608 0.258824 0.501961
239 r 376 292 388 394 0.207843 0.101961 0.0627451 0.501961
240 r 234 370 262 389 0.682353 0.501961 0.360784 0.501961
241 r 306 321 314 373 0.54902 0.309804 0.176471 0.501961
242 r 271 571 278 581 0.47451 0.45098 0.45098 0.501961
243 r 223 529 265 592 0.109804 0.117647 0.0980392 0.501961
244 r 52 617 69 671 0.494118 0.0627451 0.0666667 0.501961
245 r 216 301 224 310 0.662745 0.498039 0.384314 0.501961
246 r 253 658 263 682 0.0588235 0.0862745 0.0784314 0.501961
247 r 224 646 232 657 0.556863 0.0196078 0.0156863 0.501961
248 r 281 14 309 91 0.129412 0.14902 0.137255 0.501961
249 r 220 406 234 429 0.27451 0.164706 0.0941176 0.501961
250 r 94 518 123 584 0.392157 0.168627 0.168627 0.501961
251 r 275 441 288 467 0.458824 0.380392 0.14902 0.501961
252 r 363 463 382 489 0.372549 0.243137 0.172549 0.501961
253 r 300 349 323 364 0.741176 0.462745 0.294118 0.501961
254 r 279 197 291 262 0.529412 0.494118 0.301961 0.501961
255 r 199 442 206 502 0.192157 0.231373 0.231373 0.501961
256 r 378 597 386 650 0.384314 0.278431 0.270588 0.501961
257 r 149 431 175 451 0.411765 0.32549 0.309804 0.501961
258 r 325 300 340 318 0.266667 0.14902 0.0980392 0.501961

259 r 289 392 301 399 0.682353 0.529412 0.403922 0.501961
260 r 215 124 227 161 0.235294 0.168627 0.113725 0.501961
261 r 334 565 353 588 0.0666667 0.109804 0.152941 0.501961
262 r 288 505 307 543 0.180392 0.113725 0.0745098 0.501961
263 r 179 297 183 449 0.129412 0.14902 0.129412 0.501961
264 r 353 186 359 207 0.337255 0.176471 0.0941176 0.501961
265 r 317 258 328 272 0.47451 0.333333 0.227451 0.501961
266 r 16 112 46 148 0.266667 0.270588 0.262745 0.501961
267 r 226 334 270 357 0.564706 0.356863 0.215686 0.501961
268 r 190 289 209 317 0.364706 0.203922 0.129412 0.501961
269 r 342 377 354 406 0.309804 0.196078 0.117647 0.501961
270 r 190 320 201 341 0.160784 0.0705882 0.027451 0.501961
271 r 193 620 201 691 0.27451 0.227451 0.219608 0.501961
272 r 207 321 230 324 0.156863 0.121569 0.0588235 0.501961
273 r 199 202 233 245 0.537255 0.392157 0.223529 0.501961
274 r 297 217 335 230 0.478431 0.34902 0.219608 0.501961
275 r 323 442 351 452 0.568627 0.435294 0.341176 0.501961
276 r 366 230 381 282 0.239216 0.109804 0.0666667 0.501961
277 r 0 165 55 262 0.172549 0.215686 0.211765 0.501961
278 r 234 643 246 671 0.321569 0.282353 0.286275 0.501961
279 r 78 610 102 693 0.439216 0.164706 0.160784 0.501961
280 r 396 624 402 638 0.494118 0.0352941 0.0313726 0.501961
281 r 439 387 484 407 0.027451 0.0509804 0.0431373 0.501961
282 r 223 493 239 535 0.211765 0.156863 0.160784 0.501961
283 r 361 529 405 567 0.113725 0.113725 0.141176 0.501961
284 r 0 578 2 598 0.486275 0.054902 0.0666667 0.501961
285 r 66 660 92 709 0.415686 0.172549 0.168627 0.501961
286 r 316 237 339 249 0.231373 0.152941 0.105882 0.501961
287 r 368 296 373 338 0.443137 0.27451 0.172549 0.501961
288 r 493 543 507 655 0.0588235 0.0705882 0.0705882 0.501961
289 r 159 704 178 719 0.517647 0.172549 0.168627 0.501961
290 r 100 349 128 389 0.352941 0.34902 0.360784 0.501961
291 r 103 280 112 324 0.215686 0.235294 0.227451 0.501961
292 r 135 351 140 422 0.388235 0.368627 0.356863 0.501961
293 r 253 594 259 663 0.290196 0.258824 0.25098 0.501961
294 r 207 688 222 702 0.431373 0.0745098 0.0745098 0.501961
295 r 0 206 92 250 0.168627 0.211765 0.207843 0.501961
296 r 293 299 318 322 0.509804 0.360784 0.294118 0.501961
297 r 327 270 341 276 0.0588235 0.0431373 0.0235294 0.501961
298 r 53 157 72 206 0.305882 0.262745 0.254902 0.501961
299 r 87 538 96 562 0.427451 0.0470588 0.0509804 0.501961
300 r 121 385 128 470 0.439216 0.403922 0.376471 0.501961
301 r 314 514 326 576 0.337255 0.207843 0.133333 0.501961

302 r 274 543 298 553 0.309804 0.160784 0.0901961 0.501961
303 r 311 136 330 174 0.0980392 0.121569 0.101961 0.501961
304 r 278 660 316 688 0.313726 0.34902 0.356863 0.501961
305 r 35 654 59 695 0.462745 0.0823529 0.0823529 0.501961
306 r 508 503 535 548 0.0745098 0.0705882 0.0705882 0.501961
307 r 383 455 391 478 0.313726 0.192157 0.133333 0.501961
308 r 408 655 425 719 0.2 0.0980392 0.113725 0.501961
309 r 402 445 425 486 0.0352941 0.0509804 0.0509804 0.501961
310 r 196 344 201 377 0.470588 0.282353 0.152941 0.501961
311 r 270 640 285 656 0.0705882 0.105882 0.109804 0.501961
312 r 259 570 269 597 0.0705882 0.109804 0.12549 0.501961
313 r 325 433 335 443 0.431373 0.266667 0.188235 0.501961
314 r 68 475 73 543 0.392157 0.172549 0.164706 0.501961
315 r 186 256 224 273 0.423529 0.317647 0.239216 0.501961
316 r 221 456 270 467 0.0470588 0.0470588 0.0235294 0.501961
317 r 318 610 382 630 0.313726 0.356863 0.360784 0.501961
318 r 25 613 32 679 0.117647 0.152941 0.145098 0.501961
319 r 183 186 189 249 0.286275 0.219608 0.133333 0.501961
320 r 180 0 236 77 0.141176 0.188235 0.188235 0.501961
321 r 205 393 218 412 0.192157 0.12549 0.0823529 0.501961
322 r 0 460 60 574 0.152941 0.168627 0.152941 0.501961
323 r 345 120 376 167 0.0235294 0.0431373 0.0313726 0.501961
324 r 354 234 361 322 0.0470588 0.0745098 0.0666667 0.501961
325 r 261 355 267 373 0.380392 0.207843 0.172549 0.501961
326 r 238 311 251 348 0.533333 0.364706 0.239216 0.501961
327 r 54 555 61 599 0.364706 0.223529 0.219608 0.501961
328 r 133 458 150 489 0.321569 0.317647 0.313726 0.501961
329 r 74 434 108 509 0.321569 0.278431 0.270588 0.501961
330 r 249 203 282 212 0.690196 0.592157 0.396078 0.501961
331 r 353 634 370 651 0.439216 0.298039 0.298039 0.501961
332 r 152 551 180 664 0.290196 0.184314 0.176471 0.501961
333 r 213 640 218 662 0.0862745 0.0627451 0.0313726 0.501961
334 r 214 613 220 633 0.368627 0.215686 0.211765 0.501961
335 r 323 419 331 428 0.788235 0.545098 0.564706 0.501961
336 r 305 630 323 686 0.333333 0.341176 0.34902 0.501961
337 r 361 427 372 443 0.392157 0.266667 0.196078 0.501961
338 r 262 107 355 135 0.0313726 0.0470588 0.0352941 0.501961
339 r 210 713 230 719 0.00784314 0.0627451 0.0235294 0.501961
340 r 412 308 444 383 0.0117647 0.0235294 0.0196078 0.501961
341 r 339 46 374 110 0.101961 0.113725 0.0862745 0.501961
342 r 346 352 351 390 0.458824 0.313726 0.231373 0.501961
343 r 248 694 265 706 0.317647 0.286275 0.262745 0.501961
344 r 228 688 244 713 0.0509804 0.109804 0.0980392 0.501961

345 r 344 472 356 484 0.239216 0.113725 0.0705882 0.501961
346 r 150 352 181 387 0.0666667 0.0627451 0.0431373 0.501961
347 r 131 344 133 388 0.168627 0.196078 0.184314 0.501961
348 r 177 643 184 719 0.466667 0.231373 0.227451 0.501961
349 r 294 470 345 478 0.529412 0.352941 0.192157 0.501961
350 r 291 354 296 364 0.964706 0.843137 0.733333 0.501961
351 r 289 406 346 414 0.501961 0.239216 0.27451 0.501961
352 r 91 397 98 474 0.341176 0.345098 0.333333 0.501961
353 r 237 84 273 93 0 0.0156863 0.00392157 0.501961
354 r 436 447 459 485 0.117647 0.141176 0.156863 0.501961
355 r 293 242 306 251 0.470588 0.509804 0.329412 0.501961
356 r 98 0 152 116 0.172549 0.219608 0.211765 0.501961
357 r 117 648 139 691 0.435294 0.109804 0.109804 0.501961
358 r 242 416 260 429 0.462745 0.294118 0.180392 0.501961
359 r 183 681 193 719 0.298039 0.27451 0.266667 0.501961
360 r 266 429 279 432 0.294118 0.101961 0.121569 0.501961
361 r 439 679 532 699 0.160784 0.129412 0.145098 0.501961
362 r 47 594 53 638 0.356863 0.215686 0.211765 0.501961
363 r 258 655 273 669 0.0588235 0.0980392 0.109804 0.501961
364 r 239 186 285 196 0.454902 0.329412 0.223529 0.501961
365 r 193 708 206 719 0.403922 0.0862745 0.0823529 0.501961
366 r 123 524 131 575 0.290196 0.235294 0.258824 0.501961
367 r 87 154 110 193 0.168627 0.184314 0.180392 0.501961
368 r 346 394 356 407 0.203922 0.0862745 0.0588235 0.501961
369 r 224 397 238 410 0.490196 0.294118 0.164706 0.501961
370 r 282 373 292 381 0.709804 0.427451 0.258824 0.501961
371 r 243 712 257 719 0.521569 0.188235 0.188235 0.501961
372 r 384 481 412 497 0.0431373 0.054902 0.0627451 0.501961
373 r 281 630 297 645 0.0862745 0.109804 0.105882 0.501961
374 r 223 311 230 327 0.203922 0.172549 0.113725 0.501961
375 r 400 639 404 653 0.545098 0.0235294 0.0156863 0.501961
376 r 367 382 379 421 0.027451 0.0666667 0.0705882 0.501961
377 r 251 139 299 145 0.180392 0.14902 0.0784314 0.501961
378 r 307 296 329 310 0.396078 0.27451 0.219608 0.501961
379 r 162 277 219 285 0.145098 0.105882 0.0705882 0.501961
380 r 232 571 240 593 0.235294 0.172549 0.160784 0.501961
381 r 189 503 196 636 0.388235 0.321569 0.32549 0.501961
382 r 277 291 289 308 0.552941 0.298039 0.137255 0.501961
383 r 319 336 323 373 0.698039 0.494118 0.403922 0.501961
384 r 60 586 112 624 0.454902 0.109804 0.109804 0.501961
385 r 253 98 271 110 0.133333 0.156863 0.137255 0.501961
386 r 87 578 94 611 0.388235 0.2 0.192157 0.501961
387 r 198 376 208 386 0.360784 0.2 0.129412 0.501961

388 r 117 285 118 342 0.0901961 0.0862745 0.0627451 0.501961
389 r 291 268 312 296 0.34902 0.196078 0.117647 0.501961
390 r 482 525 497 571 0.133333 0.133333 0.156863 0.501961
391 r 381 230 457 285 0.0509804 0.0627451 0.0509804 0.501961
392 r 335 269 342 290 0.0941176 0.0588235 0.0235294 0.501961
393 r 287 424 303 434 0.698039 0.25098 0.317647 0.501961
394 r 385 379 398 420 0.168627 0.101961 0.0745098 0.501961
395 r 361 445 386 463 0.211765 0.137255 0.0980392 0.501961
396 r 282 309 300 320 0.552941 0.313726 0.172549 0.501961
397 r 172 90 216 156 0.0705882 0.0823529 0.0666667 0.501961
398 r 267 293 273 305 0.619608 0.505882 0.427451 0.501961
399 r 271 337 298 347 0.756863 0.427451 0.184314 0.501961
400 r 262 715 283 719 0.290196 0.301961 0.313726 0.501961
401 r 273 305 277 320 0.701961 0.564706 0.486275 0.501961
402 r 282 347 291 360 0.886275 0.572549 0.360784 0.501961
403 r 73 517 82 580 0.388235 0.117647 0.117647 0.501961
404 r 171 229 184 285 0.137255 0.145098 0.101961 0.501961
405 r 203 341 217 351 0.305882 0.172549 0.117647 0.501961
406 r 291 447 311 452 0.329412 0.219608 0.133333 0.501961
407 r 358 327 366 383 0.0588235 0.105882 0.109804 0.501961
408 r 239 604 256 625 0.262745 0.207843 0.2 0.501961
409 r 340 590 363 620 0.298039 0.321569 0.329412 0.501961
410 r 345 235 348 306 0.184314 0.203922 0.196078 0.501961
411 r 143 69 177 97 0.141176 0.192157 0.184314 0.501961
412 r 208 281 235 294 0.235294 0.137255 0.0784314 0.501961
413 r 203 335 224 339 0.541176 0.352941 0.290196 0.501961
414 r 147 389 160 411 0.333333 0.286275 0.262745 0.501961
415 r 218 318 223 321 0.694118 0.67451 0.654902 0.501961
416 r 250 637 266 651 0.329412 0.32549 0.333333 0.501961
417 r 224 679 231 688 0.368627 0.0392157 0.027451 0.501961
418 r 353 546 365 568 0.0784314 0.0980392 0.133333 0.501961
419 r 241 303 257 320 0.372549 0.223529 0.145098 0.501961
420 r 237 434 254 445 0.215686 0.152941 0.0784314 0.501961
421 r 318 511 368 532 0.329412 0.207843 0.133333 0.501961
422 r 189 184 213 199 0.368627 0.223529 0.117647 0.501961
423 r 321 286 332 293 0.372549 0.160784 0 0.501961
424 r 146 363 153 379 0.211765 0.172549 0.145098 0.501961
425 r 204 311 216 313 0.560784 0.388235 0.290196 0.501961
426 r 243 313 250 316 0.686275 0.443137 0.219608 0.501961
427 r 183 346 192 404 0.133333 0.2 0.184314 0.501961
428 r 299 433 319 443 0.721569 0.313726 0.364706 0.501961
429 r 208 545 220 592 0.168627 0.14902 0.156863 0.501961
430 r 220 621 227 635 0.0941176 0.117647 0.101961 0.501961

431 r 262 585 276 602 0.101961 0.113725 0.109804 0.501961
432 r 477 402 512 430 0.109804 0.141176 0.160784 0.501961
433 r 307 368 317 371 0.388235 0.196078 0.160784 0.501961
434 r 308 691 334 719 0.286275 0.282353 0.286275 0.501961
435 r 332 483 347 500 0.180392 0.105882 0.0784314 0.501961
436 r 333 198 354 217 0.0627451 0.109804 0.101961 0.501961
437 r 463 377 500 385 0.172549 0.196078 0.180392 0.501961
438 r 124 312 130 350 0.392157 0.380392 0.372549 0.501961
439 r 364 149 399 212 0.0470588 0.0588235 0.0431373 0.501961
440 r 361 214 366 248 0.341176 0.2 0.109804 0.501961
441 r 291 419 304 421 0.4 0.0470588 0.0705882 0.501961
442 r 137 378 147 395 0.403922 0.380392 0.352941 0.501961
443 r 134 680 147 719 0.341176 0.203922 0.192157 0.501961
444 r 97 192 113 233 0.133333 0.137255 0.12549 0.501961
445 r 104 308 108 366 0.278431 0.286275 0.286275 0.501961
446 r 163 360 172 408 0.0509804 0.0588235 0.0431373 0.501961
447 r 351 350 357 364 0.137255 0.196078 0.243137 0.501961
448 r 180 461 187 497 0.34902 0.32549 0.317647 0.501961
449 r 266 358 271 397 0.376471 0.309804 0.290196 0.501961
450 r 424 423 451 436 0.0117647 0.027451 0.0196078 0.501961
451 r 372 318 382 365 0.243137 0.129412 0.0823529 0.501961
452 r 208 602 215 616 0.12549 0.054902 0.0352941 0.501961
453 r 66 359 85 406 0.168627 0.188235 0.172549 0.501961
454 r 135 528 150 600 0.321569 0.109804 0.117647 0.501961
455 r 278 230 297 256 0.498039 0.443137 0.235294 0.501961
456 r 250 149 300 174 0.380392 0.231373 0.117647 0.501961
457 r 107 447 112 523 0.403922 0.270588 0.270588 0.501961
458 r 238 448 263 502 0.0784314 0.0784314 0.0588235 0.501961
459 r 224 346 244 356 0.560784 0.415686 0.313726 0.501961
460 r 313 268 333 270 0.486275 0.356863 0.270588 0.501961
461 r 66 505 103 523 0.301961 0.207843 0.203922 0.501961
462 r 310 244 324 253 0.196078 0.12549 0.0862745 0.501961
463 r 310 221 317 239 0.45098 0.443137 0.305882 0.501961
464 r 108 691 129 719 0.447059 0.133333 0.129412 0.501961
465 r 95 681 105 719 0.294118 0.12549 0.12549 0.501961
466 r 282 443 322 446 0.435294 0.258824 0.239216 0.501961
467 r 364 287 367 333 0.254902 0.2 0.184314 0.501961
468 r 438 106 467 223 0.105882 0.12549 0.0980392 0.501961
469 r 269 561 274 573 0.443137 0.411765 0.423529 0.501961
470 r 286 561 299 572 0.619608 0.392157 0.235294 0.501961
471 r 287 714 293 719 0.701961 0.0392157 0.0431373 0.501961
472 r 218 655 228 680 0.345098 0.258824 0.266667 0.501961
473 r 354 481 371 492 0.376471 0.239216 0.14902 0.501961

474 r 219 605 225 616 0.372549 0.207843 0.203922 0.501961
475 r 269 380 285 388 0.294118 0.192157 0.160784 0.501961
476 r 308 427 321 433 0.815686 0.482353 0.517647 0.501961
477 r 242 248 252 288 0.556863 0.4 0.2 0.501961
478 r 328 276 333 279 0.572549 0.560784 0.541176 0.501961
479 r 239 221 272 249 0.588235 0.486275 0.247059 0.501961
480 r 399 540 416 626 0.101961 0.101961 0.121569 0.501961
481 r 296 364 304 374 0.694118 0.372549 0.188235 0.501961
482 r 461 210 505 250 0.14902 0.168627 0.152941 0.501961
483 r 390 221 400 354 0.0784314 0.0901961 0.0784314 0.501961
484 r 297 199 329 207 0.443137 0.278431 0.133333 0.501961
485 r 145 117 191 180 0.0784314 0.0823529 0.0588235 0.501961
486 r 83 282 95 335 0.12549 0.113725 0.0901961 0.501961
487 r 281 570 286 578 0.294118 0.172549 0.113725 0.501961
488 r 269 91 290 97 0.145098 0.156863 0.145098 0.501961
489 r 165 281 186 309 0.129412 0.105882 0.0666667 0.501961
490 r 343 448 352 467 0.509804 0.309804 0.203922 0.501961
491 r 79 69 121 158 0.176471 0.223529 0.215686 0.501961
492 r 396 30 425 153 0.133333 0.156863 0.14902 0.501961
493 r 255 375 261 386 0.701961 0.564706 0.47451 0.501961
494 r 209 424 224 453 0.0392157 0.0509804 0.0392157 0.501961
495 r 268 415 293 427 0.521569 0.262745 0.317647 0.501961
496 r 163 417 166 476 0.372549 0.309804 0.305882 0.501961
497 r 230 536 283 546 0.109804 0.101961 0.0823529 0.501961
498 r 283 265 309 274 0.282353 0.180392 0.113725 0.501961
499 r 502 486 519 521 0.12549 0.12549 0.145098 0.501961
500 r 313 396 321 397 0.823529 0.572549 0.533333 0.501961
501 r 256 624 261 632 0.25098 0.121569 0.117647 0.501961
12_circle.cpp - 3157 bytes.
1 // Compile: clang++ -std=c++17 12_circle.cpp -o 12_circle

2
5 #include <tuple>
6 #include <vector>
7 #include <random>
8 #include <cmath>
9
11 {
13 }
14
16 {
18 }
19
21 height)
22 {
26 }
27 }
28 }
29
30 void draw_circle(int x, int y, int radius, std::vector<std::tuple<float, float, floa\
31 t>> &image, std::tuple<float, float, float> &color, int width, int height)
32 {
33 int x0 = 0;
34 int y0 = radius;
35 int d = 3 - 2 * radius;
36 int xx=0;
37 int yy=0;
38 unsigned char mask=255;
39 if (!radius) return;
40
41 while (y0 >= x0)
42 {
43 if (mask & 0x01) {xx=x + x0;yy=y - y0;image[get_index(xx, yy, width)]=color;}
44 if (mask & 0x02) {xx=x + y0;yy=y - x0;image[get_index(xx, yy, width)]=color;}
45 if (mask & 0x04) {xx=x + y0;yy=y + x0;image[get_index(xx, yy, width)]=color;}
46 if (mask & 0x08) {xx=x + x0;yy=y + y0;image[get_index(xx, yy, width)]=color;}
47 if (mask & 0x10) {xx=x - x0;yy=y + y0;image[get_index(xx, yy, width)]=color;}
48 if (mask & 0x20) {xx=x - y0;yy=y + x0;image[get_index(xx, yy, width)]=color;}
49 if (mask & 0x40) {xx=x - y0;yy=y - x0;image[get_index(xx, yy, width)]=color;}
50 if (mask & 0x80) {xx=x - x0;yy=y - y0;image[get_index(xx, yy, width)]=color;}
51 if (d < 0) d += 4 * x0++ + 6;
52 else d += 4 * (x0++ - y0--) + 10;
53 }
54 }
55
56 void draw_filled_circle(int x, int y, int radius, std::vector<std::tuple<float, floa\
57 t, float>> &image, std::tuple<float, float, float> &color, int width, int height)
58 {
59 int x0 = 0;
60 int y0 = radius;
61 int d = 3 - 2 * radius;
63
64 auto drawline = [&](int sx, int ex, int ny)
65 {
66 for (int i = sx; i <= ex; i++)
67 image[get_index(i, ny, width)]=color;
68 };
69
70 while (y0 >= x0)
71 {
72 drawline(x - x0, x + x0, y - y0);
73 drawline(x - y0, x + y0, y - x0);
74 drawline(x - x0, x + x0, y + y0);
75 drawline(x - y0, x + y0, y + x0);
76 if (d < 0) d += 4 * x0++ + 6;
77 else d += 4 * (x0++ - y0--) + 10;
78 }
79 }
80
83 {
88 {
89 color=image[i];
92 }
93 out.close();
94 }
95
96 int main()
97 {
98 int width=640;
99 int height=360;
100 int x1=0,y=0,r=0,x2=0;
101
102 r=((height/2)*0.8)/2;
103 y=height/2;
104 x1=((width-(((height/2)*0.8)*3))/2)+r;
105 x2=width-x1;
106
109
112
113 draw_circle(x1,y,r,image,color,width,height);
114 draw_filled_circle(x2,y,r,image,color,width,height);
115
116 save_image(image,width,height,"12_circle.ppm");
117
118 return 0;
119 }
12_circles_from_file.cpp - 6998 bytes.
1 // Compile: clang++ -std=c++17 12_circles_from_file.cpp -o 12_circles_from_file

2
5 #include <tuple>
6 #include <vector>
7 #include <random>
8 #include <cmath>
10
12 {
18 return true;
19 else
20 return false;
21 }
22
24 {
26 }
27
29 {
31 }
32
34 at,float,float> &color, int width, int height)
35 {
39 }
40 }
41 }
42
43 std::tuple<int,int,int,float,float,float,float> parse_circle_line(const std::string \
44 str)
45 {
46 size_t start;
47 size_t end = 0;
49
51 {
54 }
55
56 int dx=stoi(out[1]);
57 int dy=stoi(out[2]);
63
64 return std::make_tuple(dx,dy,r,rf,gf,bf,af);
65 }
66
69 {
70 size_t start;
71 size_t end = 0;
73
75 {
78 }
79
85
87 }
88
91 {
99
101 }
102
104 {
105 int code=0;

106 if(y >= height)
107 code |= 1; //top
108 else if(y < 0)
110 if(x >= width)
112 else if (x < 0)
113 code |= 8; //left
114 return(code);
115 }
116
119 {
129 {
134 {
135 int x, y;
138 {
139 x = x1 + (x2 - x1) * (height - y1) / (y2 - y1);
140 y = height - 1;
141 }
143 {
144 x = x1 + (x2 - x1) * -y1 / (y2 - y1);
145 y = 0;
146 }
148 {
149 y = y1 + (y2 - y1) * (width - x1) / (x2 - x1);
150 x = width - 1;
151 }
152 else //left
153 {
154 y = y1 + (y2 - y1) * -x1 / (x2 - x1);
155 x = 0;
156 }
158 {
159 x1 = x; y1 = y;
161 }
163 {
164 x2 = x; y2 = y;
166 }
167 }
168 }
170 if(accept)
171 {
172 x3 = x1;
173 x4 = x2;
174 y3 = y1;
175 y4 = y2;
177 return 1;
178 }
179 else
180 {
181 x3 = x4 = y3 = y4 = 0;
183 return 0;
184 }
185 }
186
188 t, float>> &image, std::tuple<float, float, float, float> &colorRGBA, int width, int
189 height)
190 {
191 int x0 = 0;
192 int y0 = radius;
193 int d = 3 - 2 * radius;
197
199 {
200 coords1=std::make_tuple(sx,ny,ex,ny);
202 sx=std::get<0>(coords2);
203 ny=std::get<1>(coords2);
204 ex=std::get<2>(coords2);
205 for (int i = sx; i <= ex; i++) {
206 image[get_index(i, ny, width)]=blend_colors(image[get_index(i, ny, w
207 RGBA);
208 }
209 }
210 };
211
212 while (y0 >= x0)
213 {
214 drawline(x - x0, x + x0, y - y0);
215 drawline(x - y0, x + y0, y - x0);
216 drawline(x - x0, x + x0, y + y0);
217 drawline(x - y0, x + y0, y + x0);
218 if (d < 0) d += 4 * x0++ + 6;
219 else d += 4 * (x0++ - y0--) + 10;
220 }
221 }
222
225 {
230 {
231 color=image[i];
234 }
235 out.close();
236 }
237
238 int main()
239 {
242 std::tuple<int,int,int,float,float,float,float> circle;
246 int width,height,xx,yy,r;
251 {
252 if (startsWithCaseInsensitive(line,"c")) {
253 circle=parse_circle_line(line);
254 std::tie(xx,yy,r,rf,gf,bf,af) = circle;
256 draw_filled_circle(xx,yy,r,image,colorRGBA,width,height);
257 }
264 }
265 }
266 infile.close();
267
268 save_image(image,width,height,"12_squint_with_your_eyes.ppm");
269
270 return 0;
271 }

1 b 960 720 0.329412 0.337255 0.337255
2 c 430 320 257 0.843137 0.772549 0.733333 0.501961
3 c 731 359 228 0.0588235 0.0941176 0.129412 0.501961
4 c 414 636 118 0.85098 0.858824 0.803922 0.501961
5 c 307 101 119 0.886275 0.843137 0.721569 0.501961
6 c 122 238 122 0 0.0666667 0.145098 0.501961
7 c 237 477 101 0.196078 0.192157 0.133333 0.501961
8 c 279 284 88 0.847059 0.866667 0.807843 0.501961
9 c 549 256 189 0.623529 0.552941 0.537255 0.501961
10 c 433 325 54 1 1 1 0.501961
11 c 602 702 34 0.87451 1 1 0.501961
12 c 227 366 68 0.439216 0.47451 0.419608 0.501961
13 c 359 400 55 0.921569 0.87451 0.827451 0.501961
14 c 379 233 47 0.176471 0.211765 0.243137 0.501961
15 c 88 582 88 0 0 0.054902 0.501961
16 c 604 120 128 0.376471 0.298039 0.247059 0.501961
17 c 187 609 27 0.898039 0.984314 0.941176 0.501961
18 c 528 511 105 0.596078 0.498039 0.486275 0.501961
19 c 279 602 58 0.184314 0.0784314 0 0.501961
20 c 398 539 68 0.866667 0.878431 0.811765 0.501961
21 c 757 650 32 0.576471 0.74902 0.835294 0.501961
22 c 328 695 34 0.952941 1 1 0.501961
23 c 297 476 40 0.0941176 0 0 0.501961
24 c 348 143 67 0.937255 0.94902 0.964706 0.501961
25 c 329 299 55 0.941176 0.94902 0.956863 0.501961
26 c 207 155 71 0.396078 0.415686 0.356863 0.501961
27 c 217 486 37 0.670588 0.713726 0.654902 0.501961
28 c 409 28 52 0.243137 0.109804 0 0.501961
29 c 492 471 40 0.360784 0.105882 0.152941 0.501961
30 c 438 413 28 0.972549 0.980392 0.980392 0.501961
31 c 204 552 36 0.592157 0.615686 0.568627 0.501961
32 c 136 465 55 0 0.0666667 0.160784 0.501961
33 c 572 243 32 0.0509804 0.117647 0.188235 0.501961
34 c 714 359 39 0.101961 0.0901961 0.0588235 0.501961
35 c 845 500 113 0 0.0666667 0.145098 0.501961
36 c 83 110 83 0 0.105882 0.168627 0.501961
37 c 820 685 55 0 0 0 0.501961
38 c 645 566 13 0.847059 1 1 0.501961
39 c 290 427 25 0.0745098 0 0 0.501961
40 c 621 430 41 0.639216 0.603922 0.611765 0.501961
41 c 344 44 25 0.337255 0.203922 0.0745098 0.501961
42 c 329 234 15 0.160784 0.0509804 0.0431373 0.501961
43 c 358 457 26 0.921569 0.937255 0.87451 0.501961

44 c 230 359 64 0.486275 0.501961 0.454902 0.501961
45 c 704 38 76 0.152941 0.113725 0.0470588 0.501961
46 c 691 535 46 0.0980392 0.00784314 0 0.501961
47 c 218 29 32 0.768627 0.803922 0.705882 0.501961
48 c 366 209 28 0.341176 0.266667 0.223529 0.501961
49 c 142 695 27 0 0 0 0.501961
50 c 317 669 23 0.8 1 1 0.501961
51 c 625 686 15 0.709804 0.909804 0.988235 0.501961
52 c 447 332 32 0.984314 1 1 0.501961
53 c 459 274 22 0.898039 0.956863 0.94902 0.501961
54 c 401 373 33 0.6 0.521569 0.498039 0.501961
55 c 239 684 39 0.235294 0.141176 0 0.501961
56 c 296 211 29 0.956863 0.937255 0.913725 0.501961
57 c 188 704 16 0.866667 0.776471 0.54902 0.501961
58 c 695 673 49 0.231373 0.141176 0.0352941 0.501961
59 c 282 379 16 0.223529 0.0980392 0 0.501961
60 c 744 613 16 0.490196 0.662745 0.764706 0.501961
61 c 271 90 21 0.32549 0.294118 0.196078 0.501961
62 c 406 686 41 0.447059 0.419608 0.388235 0.501961
63 c 274 538 46 0.215686 0.121569 0.0352941 0.501961
64 c 188 632 15 0.929412 0.964706 0.901961 0.501961
65 c 565 29 58 0.219608 0.133333 0.0470588 0.501961
66 c 753 677 24 0.435294 0.552941 0.611765 0.501961
67 c 688 465 40 0.156863 0.0666667 0 0.501961
68 c 681 611 41 0.168627 0.0627451 0 0.501961
69 c 658 185 45 0.537255 0.521569 0.533333 0.501961
70 c 399 130 62 0.827451 0.819608 0.811765 0.501961
71 c 254 464 18 0.811765 0.729412 0.54902 0.501961
72 c 212 617 20 0.364706 0.239216 0.0980392 0.501961
73 c 338 702 33 0.85098 1 1 0.501961
74 c 168 71 31 0.384314 0.431373 0.415686 0.501961
75 c 505 310 35 0.501961 0.411765 0.392157 0.501961
76 c 307 64 19 0.407843 0.278431 0.14902 0.501961
77 c 298 265 28 0.988235 0.988235 0.968627 0.501961
78 c 529 619 78 0.494118 0.466667 0.423529 0.501961
79 c 582 709 19 0.858824 1 1 0.501961
80 c 573 510 46 0.588235 0.588235 0.576471 0.501961
81 c 751 209 57 0.309804 0.27451 0.239216 0.501961
82 c 233 151 26 0.337255 0.27451 0.180392 0.501961
83 c 362 682 16 0.286275 0.258824 0.243137 0.501961
84 c 387 240 17 0 0.0784314 0.141176 0.501961
85 c 152 622 25 0.207843 0.321569 0.364706 0.501961
86 c 71 597 71 0 0.101961 0.168627 0.501961

87 c 212 574 17 0.819608 0.776471 0.627451 0.501961
88 c 364 280 16 0.403922 0.403922 0.423529 0.501961
89 c 874 142 85 0 0.0627451 0.137255 0.501961
90 c 210 312 35 0.596078 0.647059 0.603922 0.501961
91 c 186 605 12 0.996078 1 1 0.501961
92 c 181 553 25 0.164706 0.258824 0.309804 0.501961
93 c 614 635 32 0.207843 0.129412 0.0627451 0.501961
94 c 448 451 12 0.301961 0.0117647 0.0313726 0.501961
95 c 767 638 22 0.466667 0.611765 0.682353 0.501961
96 c 335 17 35 0.803922 0.717647 0.560784 0.501961
97 c 203 431 23 0.482353 0.564706 0.572549 0.501961
98 c 316 370 22 0.921569 0.890196 0.839216 0.501961
99 c 266 21 16 0.458824 0.313726 0.0901961 0.501961
100 c 333 143 39 0.952941 0.956863 0.945098 0.501961
101 c 314 534 27 0.34902 0.294118 0.215686 0.501961
102 c 341 644 18 0.396078 0.341176 0.282353 0.501961
103 c 632 336 52 0.623529 0.54902 0.545098 0.501961
104 c 351 246 10 0.768627 1 1 0.501961
105 c 221 73 29 0.745098 0.756863 0.619608 0.501961
106 c 251 202 24 0.533333 0.490196 0.392157 0.501961
107 c 433 64 20 0.717647 0.647059 0.564706 0.501961
108 c 641 667 14 0.533333 0.607843 0.619608 0.501961
109 c 297 465 34 0.203922 0.0980392 0 0.501961
110 c 443 473 18 0.839216 0.627451 0.682353 0.501961
111 c 398 586 67 0.72549 0.721569 0.666667 0.501961
112 c 190 244 29 0.25098 0.329412 0.341176 0.501961
113 c 482 88 44 0.6 0.521569 0.454902 0.501961
114 c 741 322 38 0.239216 0.254902 0.254902 0.501961
115 c 605 244 13 0.411765 0.690196 0.866667 0.501961
116 c 649 514 33 0.0588235 0.0745098 0.0745098 0.501961
117 c 256 354 34 0.415686 0.403922 0.341176 0.501961
118 c 703 400 33 0.188235 0.129412 0.0705882 0.501961
119 c 200 652 20 0.619608 0.533333 0.34902 0.501961
120 c 829 686 65 0 0 0 0.501961
121 c 339 436 19 0.894118 0.894118 0.85098 0.501961
122 c 592 225 18 0.0588235 0.0862745 0.141176 0.501961
123 c 646 125 51 0.47451 0.427451 0.4 0.501961
124 c 712 491 31 0.282353 0.266667 0.223529 0.501961
125 c 573 683 22 0.403922 0.34902 0.290196 0.501961
126 c 312 295 29 0.980392 0.992157 0.972549 0.501961
127 c 458 361 19 0.988235 0.996078 0.992157 0.501961
128 c 190 589 10 0.909804 1 1 0.501961
129 c 464 562 19 0.435294 0.431373 0.419608 0.501961

130 c 205 105 27 0.560784 0.54902 0.443137 0.501961
131 c 447 24 30 0.211765 0.133333 0.0627451 0.501961
132 c 451 495 17 0.47451 0.360784 0.337255 0.501961
133 c 356 492 17 0.901961 0.905882 0.839216 0.501961
134 c 492 395 19 0.423529 0.32549 0.341176 0.501961
135 c 285 40 23 0.823529 0.705882 0.490196 0.501961
136 c 538 698 28 0.470588 0.415686 0.356863 0.501961
137 c 51 694 38 0.00392157 0.0117647 0.0313726 0.501961
138 c 317 651 14 0.721569 0.839216 0.901961 0.501961
139 c 377 322 38 0.721569 0.721569 0.717647 0.501961
140 c 324 411 16 0.92549 0.921569 0.87451 0.501961
141 c 599 705 19 0.717647 0.917647 1 0.501961
142 c 163 585 18 0.239216 0.329412 0.356863 0.501961
143 c 238 491 11 0.901961 0.835294 0.658824 0.501961
144 c 415 453 7 0.180392 0 0.00784314 0.501961
145 c 672 262 37 0.580392 0.552941 0.54902 0.501961
146 c 695 355 16 0.0705882 0.027451 0 0.501961
147 c 731 598 10 0.458824 0.596078 0.682353 0.501961
148 c 171 305 26 0.341176 0.411765 0.407843 0.501961
149 c 71 340 71 0 0.101961 0.168627 0.501961
150 c 197 355 16 0.647059 0.678431 0.619608 0.501961
151 c 285 692 20 0.466667 0.435294 0.309804 0.501961
152 c 728 230 37 0.392157 0.333333 0.305882 0.501961
153 c 221 548 11 0.8 0.741176 0.607843 0.501961
154 c 473 527 16 0.772549 0.768627 0.772549 0.501961
155 c 314 242 11 0.505882 0.447059 0.407843 0.501961
156 c 345 197 21 0.658824 0.615686 0.576471 0.501961
157 c 344 75 18 0.682353 0.619608 0.552941 0.501961
158 c 785 342 82 0.184314 0.227451 0.247059 0.501961
159 c 534 455 12 0.258824 0.054902 0.0901961 0.501961
160 c 185 621 11 0.917647 1 1 0.501961
161 c 160 133 35 0.262745 0.337255 0.372549 0.501961
162 c 249 646 27 0.192157 0.121569 0.0431373 0.501961
163 c 643 709 20 0.25098 0.231373 0.180392 0.501961
164 c 359 39 19 0.337255 0.262745 0.176471 0.501961
165 c 260 267 12 0.568627 0.458824 0.321569 0.501961
166 c 348 665 10 0.282353 0.239216 0.211765 0.501961
167 c 287 400 16 0.301961 0.192157 0.0823529 0.501961
168 c 349 228 9 0.0117647 0.00784314 0.0470588 0.501961
169 c 247 398 18 0.619608 0.631373 0.588235 0.501961
170 c 490 165 51 0.592157 0.537255 0.509804 0.501961
171 c 516 224 36 0.454902 0.431373 0.45098 0.501961
172 c 492 7 11 0.768627 0.662745 0.486275 0.501961

173 c 387 654 33 0.631373 0.623529 0.568627 0.501961
174 c 150 189 43 0.145098 0.219608 0.258824 0.501961
175 c 149 629 27 0.227451 0.290196 0.321569 0.501961
176 c 406 266 25 0.392157 0.415686 0.439216 0.501961
177 c 751 106 60 0.294118 0.258824 0.196078 0.501961
178 c 212 408 11 0.705882 0.768627 0.729412 0.501961
179 c 215 445 31 0.34902 0.4 0.4 0.501961
180 c 333 698 24 0.847059 0.992157 1 0.501961
181 c 327 51 15 0.321569 0.215686 0.133333 0.501961
182 c 365 532 29 0.831373 0.831373 0.764706 0.501961
183 c 326 613 19 0.298039 0.247059 0.203922 0.501961
184 c 138 702 23 0 0 0 0.501961
185 c 230 366 26 0.298039 0.4 0.443137 0.501961
186 c 134 20 40 0.054902 0.137255 0.196078 0.501961
187 c 651 578 8 0.6 0.686275 0.72549 0.501961
188 c 556 270 25 0.364706 0.309804 0.305882 0.501961
189 c 288 157 25 0.819608 0.796078 0.745098 0.501961
190 c 462 678 26 0.494118 0.47451 0.435294 0.501961
191 c 271 316 15 0.654902 0.572549 0.439216 0.501961
192 c 379 703 11 0.258824 0.235294 0.219608 0.501961
193 c 376 203 20 0.462745 0.388235 0.337255 0.501961
194 c 297 439 22 0.145098 0.0588235 0 0.501961
195 c 283 245 16 0.976471 0.964706 0.937255 0.501961
196 c 88 493 88 0.0470588 0.145098 0.207843 0.501961
197 c 719 628 18 0.141176 0.0823529 0.0196078 0.501961
198 c 639 610 29 0.137255 0.0784314 0.0313726 0.501961
199 c 499 454 15 0.282353 0.121569 0.133333 0.501961
200 c 878 93 80 0.0352941 0.121569 0.172549 0.501961
201 c 427 418 30 0.788235 0.784314 0.776471 0.501961
202 c 367 239 5 0.729412 1 1 0.501961
203 c 727 703 20 0.0980392 0.0627451 0.0156863 0.501961
204 c 615 470 22 0.568627 0.54902 0.552941 0.501961
205 c 675 538 24 0.0509804 0 0 0.501961
206 c 426 471 13 0.847059 0.784314 0.807843 0.501961
207 c 192 517 24 0.333333 0.403922 0.427451 0.501961
208 c 627 229 14 0.168627 0.188235 0.254902 0.501961
209 c 645 561 12 0.572549 0.721569 0.807843 0.501961
210 c 432 452 7 0.356863 0.0509804 0.0627451 0.501961
211 c 205 603 12 0.380392 0.329412 0.215686 0.501961
212 c 199 157 20 0.423529 0.447059 0.423529 0.501961
213 c 683 430 18 0.0627451 0.00392157 0 0.501961
214 c 503 25 16 0.313726 0.2 0.0784314 0.501961
215 c 253 42 15 0.541176 0.466667 0.27451 0.501961

216 c 274 451 15 0.462745 0.32549 0.203922 0.501961
217 c 288 77 11 0.352941 0.278431 0.172549 0.501961
218 c 520 624 49 0.501961 0.486275 0.458824 0.501961
219 c 402 454 9 0.337255 0.247059 0.215686 0.501961
220 c 458 389 7 0.407843 0.176471 0.141176 0.501961
221 c 452 312 23 0.929412 0.956863 0.952941 0.501961
222 c 566 715 8 0.862745 1 1 0.501961
223 c 158 346 23 0.14902 0.235294 0.282353 0.501961
224 c 722 174 27 0.243137 0.235294 0.203922 0.501961
225 c 365 712 13 0.772549 0.952941 1 0.501961
226 c 261 64 12 0.843137 0.792157 0.619608 0.501961
227 c 594 675 16 0.286275 0.243137 0.196078 0.501961
228 c 267 611 12 0.498039 0.431373 0.317647 0.501961
229 c 881 580 78 0.027451 0.12549 0.180392 0.501961
230 c 284 363 10 0.27451 0.188235 0.0862745 0.501961
231 c 708 585 20 0.32549 0.266667 0.176471 0.501961
232 c 320 668 15 0.843137 0.972549 1 0.501961
233 c 463 473 10 0.764706 0.572549 0.627451 0.501961
234 c 321 82 14 0.694118 0.631373 0.556863 0.501961
235 c 612 239 9 0.556863 0.745098 0.854902 0.501961
236 c 558 454 9 0.258824 0.101961 0.133333 0.501961
237 c 657 657 20 0.34902 0.333333 0.27451 0.501961
238 c 403 28 16 0.270588 0.188235 0.109804 0.501961
239 c 438 189 22 0.701961 0.67451 0.658824 0.501961
240 c 226 506 12 0.733333 0.686275 0.545098 0.501961
241 c 583 244 7 0 0 0 0.501961
242 c 635 538 20 0.176471 0.223529 0.243137 0.501961
243 c 275 569 20 0.0901961 0.0431373 0.0196078 0.501961
244 c 522 494 25 0.470588 0.376471 0.388235 0.501961
245 c 653 399 21 0.54902 0.513726 0.52549 0.501961
246 c 257 370 18 0.6 0.580392 0.494118 0.501961
247 c 390 382 36 0.670588 0.596078 0.576471 0.501961
248 c 652 212 21 0.552941 0.533333 0.572549 0.501961
249 c 514 299 36 0.505882 0.447059 0.435294 0.501961
250 c 800 198 41 0.160784 0.2 0.223529 0.501961
251 c 206 705 14 0.403922 0.32549 0.207843 0.501961
252 c 736 31 62 0.172549 0.152941 0.121569 0.501961
253 c 238 569 19 0.380392 0.313726 0.215686 0.501961
254 c 362 12 22 0.647059 0.576471 0.458824 0.501961
255 c 261 502 15 0.168627 0.101961 0.0313726 0.501961
256 c 400 59 15 0.678431 0.631373 0.596078 0.501961
257 c 193 677 10 0.231373 0.164706 0.0235294 0.501961
258 c 417 247 18 0.356863 0.313726 0.301961 0.501961

259 c 619 175 14 0.337255 0.27451 0.247059 0.501961
260 c 314 172 16 0.988235 0.988235 0.980392 0.501961
261 c 612 668 11 0.180392 0.137255 0.0941176 0.501961
262 c 324 473 16 0.145098 0.121569 0.0862745 0.501961
263 c 673 490 21 0.0745098 0.0235294 0 0.501961
264 c 186 598 10 0.890196 1 1 0.501961
265 c 325 563 14 0.501961 0.423529 0.317647 0.501961
266 c 366 227 9 0.0470588 0.101961 0.160784 0.501961
267 c 744 287 36 0.329412 0.298039 0.27451 0.501961
268 c 616 690 12 0.654902 0.8 0.862745 0.501961
269 c 375 252 12 0.0392157 0.196078 0.290196 0.501961
270 c 247 240 12 0.870588 0.835294 0.780392 0.501961
271 c 583 327 43 0.529412 0.431373 0.403922 0.501961
272 c 895 707 23 0 0 0.00392157 0.501961
273 c 420 223 17 0.517647 0.443137 0.396078 0.501961
274 c 307 340 19 0.929412 0.898039 0.835294 0.501961
275 c 415 127 25 0.729412 0.701961 0.678431 0.501961
276 c 107 697 14 0.176471 0.305882 0.384314 0.501961
277 c 199 316 15 0.654902 0.67451 0.627451 0.501961
278 c 438 92 24 0.721569 0.690196 0.666667 0.501961
279 c 457 415 16 0.843137 0.827451 0.823529 0.501961
280 c 174 573 15 0.290196 0.337255 0.34902 0.501961
281 c 438 279 18 0.709804 0.760784 0.772549 0.501961
282 c 623 578 18 0.227451 0.180392 0.137255 0.501961
283 c 291 102 12 0.72549 0.72549 0.666667 0.501961
284 c 315 391 15 0.854902 0.85098 0.8 0.501961
285 c 308 22 24 0.768627 0.682353 0.521569 0.501961
286 c 344 255 15 0.701961 0.784314 0.847059 0.501961
287 c 228 68 13 0.823529 0.839216 0.733333 0.501961
288 c 232 154 16 0.290196 0.235294 0.164706 0.501961
289 c 678 581 21 0.101961 0.0470588 0 0.501961
290 c 226 404 6 0.65098 0.827451 0.870588 0.501961
291 c 260 122 19 0.454902 0.462745 0.419608 0.501961
292 c 387 523 38 0.796078 0.792157 0.745098 0.501961
293 c 228 220 19 0.552941 0.556863 0.509804 0.501961
294 c 465 275 10 0.945098 0.964706 0.960784 0.501961
295 c 491 561 14 0.376471 0.34902 0.352941 0.501961
296 c 900 304 59 0.0431373 0.137255 0.188235 0.501961
297 c 182 17 21 0.360784 0.447059 0.45098 0.501961
298 c 285 667 15 0.32549 0.27451 0.184314 0.501961
299 c 337 232 12 0.215686 0.168627 0.160784 0.501961
300 c 388 713 8 0.254902 0.207843 0.192157 0.501961
301 c 347 450 18 0.839216 0.827451 0.792157 0.501961

302 c 753 704 9 0.392157 0.454902 0.47451 0.501961
303 c 525 340 39 0.537255 0.466667 0.470588 0.501961
304 c 601 270 14 0.317647 0.32549 0.372549 0.501961
305 c 133 419 51 0.0784314 0.156863 0.207843 0.501961
306 c 442 373 11 0.913725 0.87451 0.831373 0.501961
307 c 700 298 18 0.501961 0.478431 0.447059 0.501961
308 c 690 382 15 0.113725 0.0745098 0.0352941 0.501961
309 c 609 21 37 0.258824 0.211765 0.152941 0.501961
310 c 284 519 18 0.368627 0.309804 0.223529 0.501961
311 c 213 565 13 0.733333 0.717647 0.623529 0.501961
312 c 554 102 60 0.462745 0.384314 0.337255 0.501961
313 c 619 413 48 0.552941 0.513726 0.517647 0.501961
314 c 347 269 8 0.501961 0.513726 0.533333 0.501961
315 c 255 448 9 0.709804 0.666667 0.545098 0.501961
316 c 568 692 17 0.407843 0.384314 0.34902 0.501961
317 c 231 443 14 0.243137 0.278431 0.27451 0.501961
318 c 199 279 18 0.45098 0.501961 0.482353 0.501961
319 c 184 701 8 0.803922 0.811765 0.705882 0.501961
320 c 331 639 9 0.34902 0.298039 0.239216 0.501961
321 c 323 220 12 0.654902 0.580392 0.556863 0.501961
322 c 448 454 7 0.219608 0.0627451 0.0588235 0.501961
323 c 545 257 11 0.235294 0.160784 0.14902 0.501961
324 c 421 348 16 0.74902 0.717647 0.682353 0.501961
325 c 513 385 5 0.247059 0.0431373 0.027451 0.501961
326 c 151 669 17 0.054902 0.0784314 0.0627451 0.501961
327 c 92 679 12 0 0 0 0.501961
328 c 298 423 14 0.105882 0.0509804 0.00784314 0.501961
329 c 256 88 16 0.423529 0.419608 0.34902 0.501961
330 c 613 222 10 0.141176 0.141176 0.188235 0.501961
331 c 751 625 18 0.423529 0.552941 0.627451 0.501961
332 c 262 19 7 0.219608 0.188235 0.121569 0.501961
333 c 358 348 33 0.780392 0.729412 0.694118 0.501961
334 c 762 596 17 0.0980392 0.168627 0.207843 0.501961
335 c 386 444 14 0.611765 0.607843 0.564706 0.501961
336 c 231 532 12 0.478431 0.380392 0.254902 0.501961
337 c 392 291 17 0.631373 0.623529 0.639216 0.501961
338 c 282 348 8 0.376471 0.25098 0.12549 0.501961
339 c 639 69 32 0.4 0.333333 0.298039 0.501961
340 c 670 454 16 0.0823529 0.027451 0 0.501961
341 c 664 316 22 0.580392 0.580392 0.580392 0.501961
342 c 259 251 8 0.584314 0.494118 0.380392 0.501961
343 c 364 62 12 0.686275 0.631373 0.564706 0.501961
344 c 580 625 24 0.415686 0.376471 0.341176 0.501961

345 c 801 664 19 0.0196078 0.0352941 0.054902 0.501961
346 c 307 632 12 0.470588 0.470588 0.427451 0.501961
347 c 265 411 14 0.498039 0.403922 0.270588 0.501961
348 c 268 683 20 0.439216 0.368627 0.25098 0.501961
349 c 661 134 22 0.498039 0.470588 0.458824 0.501961
350 c 251 593 15 0.129412 0.105882 0.0666667 0.501961
351 c 746 205 23 0.384314 0.333333 0.298039 0.501961
352 c 570 446 7 0.223529 0.180392 0.160784 0.501961
353 c 489 707 14 0.713726 0.721569 0.701961 0.501961
354 c 369 695 9 0.282353 0.25098 0.227451 0.501961
355 c 413 372 17 0.6 0.533333 0.501961 0.501961
356 c 261 298 20 0.690196 0.658824 0.568627 0.501961
357 c 449 47 13 0.470588 0.364706 0.25098 0.501961
358 c 619 260 12 0.305882 0.305882 0.364706 0.501961
359 c 380 245 7 0 0 0 0.501961
360 c 440 621 27 0.678431 0.686275 0.662745 0.501961
361 c 625 706 13 0.435294 0.54902 0.607843 0.501961
362 c 492 427 10 0.678431 0.658824 0.654902 0.501961
363 c 280 21 14 0.635294 0.501961 0.309804 0.501961
364 c 213 13 13 0.729412 0.752941 0.709804 0.501961
365 c 161 605 15 0.25098 0.317647 0.352941 0.501961
366 c 531 707 24 0.415686 0.368627 0.32549 0.501961
367 c 424 316 23 0.843137 0.87451 0.886275 0.501961
368 c 359 681 8 0.278431 0.231373 0.192157 0.501961
369 c 555 163 20 0.529412 0.462745 0.470588 0.501961
370 c 131 644 16 0.2 0.298039 0.360784 0.501961
371 c 692 679 38 0.227451 0.184314 0.121569 0.501961
372 c 761 685 9 0.454902 0.580392 0.647059 0.501961
373 c 709 492 18 0.32549 0.282353 0.223529 0.501961
374 c 258 160 14 0.568627 0.576471 0.517647 0.501961
375 c 372 241 4 0.564706 0.713726 0.811765 0.501961
376 c 517 457 6 0.105882 0.00392157 0 0.501961
377 c 92 706 18 0.133333 0.243137 0.305882 0.501961
378 c 573 186 12 0.278431 0.239216 0.211765 0.501961
379 c 232 385 16 0.294118 0.388235 0.423529 0.501961
380 c 753 501 36 0.121569 0.180392 0.215686 0.501961
381 c 182 633 8 0.796078 0.952941 1 0.501961
382 c 553 215 11 0.486275 0.439216 0.462745 0.501961
383 c 566 258 6 0.435294 0.572549 0.65098 0.501961
384 c 816 75 38 0.164706 0.192157 0.211765 0.501961
385 c 306 63 12 0.384314 0.298039 0.207843 0.501961
386 c 208 455 17 0.470588 0.52549 0.509804 0.501961
387 c 578 555 26 0.482353 0.466667 0.435294 0.501961

388 c 379 198 7 0.270588 0.196078 0.141176 0.501961
389 c 481 338 10 0.721569 0.631373 0.635294 0.501961
390 c 640 561 10 0.556863 0.670588 0.72549 0.501961
391 c 698 340 16 0.168627 0.129412 0.0784314 0.501961
392 c 78 228 45 0.054902 0.141176 0.196078 0.501961
393 c 771 98 21 0.337255 0.309804 0.247059 0.501961
394 c 215 128 14 0.529412 0.494118 0.376471 0.501961
395 c 338 43 11 0.290196 0.2 0.113725 0.501961
396 c 585 685 13 0.333333 0.309804 0.282353 0.501961
397 c 780 436 65 0.101961 0.168627 0.211765 0.501961
398 c 329 510 11 0.368627 0.384314 0.380392 0.501961
399 c 716 414 23 0.258824 0.227451 0.192157 0.501961
400 c 303 448 21 0.156863 0.0823529 0.0431373 0.501961
401 c 602 199 13 0.501961 0.454902 0.490196 0.501961
402 c 219 679 11 0.113725 0.0901961 0.0627451 0.501961
403 c 508 344 17 0.458824 0.368627 0.34902 0.501961
404 c 443 556 10 0.560784 0.552941 0.517647 0.501961
405 c 357 239 6 0.54902 0.764706 0.862745 0.501961
406 c 787 613 17 0.0784314 0.152941 0.2 0.501961
407 c 514 371 12 0.607843 0.564706 0.588235 0.501961
408 c 288 612 20 0.360784 0.286275 0.192157 0.501961
409 c 182 611 9 0.87451 1 1 0.501961
410 c 180 457 14 0.235294 0.294118 0.313726 0.501961
411 c 174 121 17 0.356863 0.415686 0.423529 0.501961
412 c 252 205 16 0.529412 0.505882 0.423529 0.501961
413 c 762 45 13 0.317647 0.294118 0.235294 0.501961
414 c 633 276 18 0.560784 0.52549 0.533333 0.501961
415 c 397 600 19 0.643137 0.643137 0.596078 0.501961
416 c 284 381 14 0.313726 0.247059 0.180392 0.501961
417 c 595 178 11 0.294118 0.239216 0.2 0.501961
418 c 248 460 9 0.752941 0.737255 0.635294 0.501961
419 c 244 480 9 0.811765 0.768627 0.635294 0.501961
420 c 198 622 7 0.713726 0.705882 0.635294 0.501961
421 c 632 674 9 0.576471 0.701961 0.741176 0.501961
422 c 274 643 20 0.180392 0.121569 0.0627451 0.501961
423 c 190 658 16 0.545098 0.482353 0.356863 0.501961
424 c 280 55 13 0.784314 0.745098 0.619608 0.501961
425 c 333 72 14 0.627451 0.564706 0.490196 0.501961
426 c 185 46 13 0.419608 0.47451 0.454902 0.501961
427 c 484 596 25 0.537255 0.552941 0.537255 0.501961
428 c 174 682 14 0.294118 0.270588 0.192157 0.501961
429 c 686 223 19 0.505882 0.47451 0.454902 0.501961
430 c 150 53 19 0.180392 0.25098 0.290196 0.501961

431 c 443 467 6 0.901961 0.831373 0.894118 0.501961
432 c 585 491 39 0.533333 0.521569 0.521569 0.501961
433 c 609 519 15 0.423529 0.396078 0.360784 0.501961
434 c 257 390 8 0.768627 0.713726 0.615686 0.501961
435 c 231 637 23 0.305882 0.25098 0.164706 0.501961
436 c 155 365 20 0.133333 0.211765 0.258824 0.501961
437 c 271 326 15 0.607843 0.52549 0.415686 0.501961
438 c 167 96 10 0.121569 0.176471 0.211765 0.501961
439 c 670 607 18 0.109804 0.0431373 0 0.501961
440 c 479 32 21 0.360784 0.282353 0.2 0.501961
441 c 508 439 13 0.478431 0.333333 0.364706 0.501961
442 c 327 240 7 0.2 0.156863 0.14902 0.501961
443 c 193 582 7 0.733333 0.882353 0.937255 0.501961
444 c 640 500 19 0.184314 0.215686 0.235294 0.501961
445 c 819 145 36 0.133333 0.184314 0.219608 0.501961
446 c 372 277 9 0.415686 0.376471 0.388235 0.501961
447 c 705 522 13 0.294118 0.262745 0.192157 0.501961
448 c 717 674 16 0.298039 0.27451 0.227451 0.501961
449 c 330 200 14 0.788235 0.788235 0.772549 0.501961
450 c 556 28 23 0.227451 0.168627 0.113725 0.501961
451 c 479 458 9 0.321569 0.141176 0.141176 0.501961
452 c 318 606 12 0.2 0.160784 0.121569 0.501961
453 c 455 253 13 0.694118 0.694118 0.65098 0.501961
454 c 295 203 25 0.886275 0.87451 0.847059 0.501961
455 c 560 668 27 0.462745 0.427451 0.380392 0.501961
456 c 356 476 16 0.835294 0.831373 0.784314 0.501961
457 c 739 229 13 0.462745 0.396078 0.392157 0.501961
458 c 371 213 12 0.509804 0.454902 0.443137 0.501961
459 c 454 340 14 1 1 1 0.501961
460 c 724 565 18 0.223529 0.172549 0.0941176 0.501961
461 c 74 659 10 0 0 0.0117647 0.501961
462 c 303 505 19 0.290196 0.235294 0.164706 0.501961
463 c 350 632 15 0.6 0.560784 0.501961 0.501961
464 c 428 394 16 0.74902 0.741176 0.74902 0.501961
465 c 228 458 8 0.235294 0.262745 0.27451 0.501961
466 c 599 584 16 0.388235 0.34902 0.301961 0.501961
467 c 216 485 17 0.419608 0.462745 0.45098 0.501961
468 c 814 350 19 0.223529 0.258824 0.278431 0.501961
469 c 679 70 21 0.282353 0.258824 0.223529 0.501961
470 c 360 196 7 0.368627 0.294118 0.231373 0.501961
471 c 212 242 14 0.431373 0.462745 0.447059 0.501961
472 c 498 291 11 0.458824 0.352941 0.286275 0.501961
473 c 323 582 11 0.4 0.345098 0.262745 0.501961

474 c 203 428 15 0.498039 0.541176 0.513726 0.501961
475 c 241 275 14 0.756863 0.729412 0.631373 0.501961
476 c 273 393 11 0.490196 0.403922 0.301961 0.501961
477 c 724 258 11 0.329412 0.196078 0.164706 0.501961
478 c 216 483 6 0.682353 0.698039 0.643137 0.501961
479 c 204 542 11 0.25098 0.313726 0.329412 0.501961
480 c 429 702 34 0.490196 0.47451 0.454902 0.501961
481 c 598 53 21 0.376471 0.321569 0.294118 0.501961
482 c 853 305 46 0.137255 0.188235 0.223529 0.501961
483 c 142 582 20 0.0705882 0.152941 0.203922 0.501961
484 c 123 134 25 0.14902 0.211765 0.25098 0.501961
485 c 387 259 8 0.156863 0.309804 0.407843 0.501961
486 c 488 525 20 0.654902 0.603922 0.580392 0.501961
487 c 356 259 8 0.662745 0.870588 0.976471 0.501961
488 c 155 186 11 0.0666667 0.133333 0.192157 0.501961
489 c 226 423 13 0.294118 0.352941 0.372549 0.501961
490 c 374 32 14 0.333333 0.258824 0.164706 0.501961
491 c 775 645 16 0.411765 0.529412 0.592157 0.501961
492 c 723 642 13 0.207843 0.168627 0.117647 0.501961
493 c 597 245 9 0.247059 0.411765 0.533333 0.501961
494 c 451 22 17 0.188235 0.12549 0.0862745 0.501961
495 c 481 417 10 0.498039 0.407843 0.388235 0.501961
496 c 552 436 13 0.52549 0.556863 0.568627 0.501961
497 c 452 441 7 0.647059 0.4 0.4 0.501961
498 c 349 568 16 0.760784 0.760784 0.682353 0.501961
499 c 341 430 22 0.831373 0.815686 0.772549 0.501961
500 c 407 183 15 0.733333 0.698039 0.678431 0.501961
501 c 399 203 9 0.392157 0.278431 0.176471 0.501961
12_wedge.cpp - 5661 bytes.
1 // Compile: clang++ -std=c++17 12_wedge.cpp -o 12_wedge

3
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
11

13 {
15 }
16
18 {
20 }
21
23 height)
24 {
28 }
29 }
30 }
31
32 void get_all_ys(std::vector<int> &ys,std::vector<std::tuple<int,int>> &coords)
33 {
34 for (auto& c : coords) {
35 ys.push_back(std::get<1>(c));
36 }
37
38 sort(ys.begin(), ys.end());
39 ys.erase( unique( ys.begin(), ys.end() ), ys.end() );
40 }
41
42 void draw_line_coords(int x1, int y1, int x2, int y2,std::vector<std::tuple<int,int>\
43 > &coords)
44 {
46 dx = x2 - x1; dy = y2 - y1;
47 if (dx == 0)
48 {
49 if (y2 < y1) std::swap(y1, y2);
50 for (y = y1; y <= y2; y++)
51 coords.push_back(std::make_tuple(x1,y));
52 return;
53 }
54 if (dy == 0)
55 {
56 if (x2 < x1) std::swap(x1, x2);
57 for (x = x1; x <= x2; x++)
58 coords.push_back(std::make_tuple(x,y1));
59 return;
60 }
62 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
63 if (dy1 <= dx1)
64 {
65 if (dx >= 0)
66 {
67 x = x1; y = y1; xe = x2;
68 }
69 else
70 {
71 x = x2; y = y2; xe = x1;
72 }
73 coords.push_back(std::make_tuple(x,y));
74 for (i = 0; x<xe; i++)
75 {
76 x = x + 1;
77 if (px<0)
78 px = px + 2 * dy1;
79 else
80 {
82 px = px + 2 * (dy1 - dx1);
83 }
85 }
86 }
87 else
88 {
89 if (dy >= 0)
90 {
91 x = x1; y = y1; ye = y2;
92 }
93 else
94 {
95 x = x2; y = y2; ye = y1;
96 }
98 for (i = 0; y<ye; i++)

99 {
100 y = y + 1;
101 if (py <= 0)
102 py = py + 2 * dx1;
103 else
104 {
106 py = py + 2 * (dx1 - dy1);
107 }
109 }
110 }
111 }
112
113 void draw_wedge(int x_cen,int y_cen,int rad,int start_ang,int end_ang,std::vector<st\
114 d::tuple<float, float, float>> &image,std::tuple<float, float, float> &color, int wi
115 dth, int height)
116 {
117 std::vector<std::tuple<int,int>> coords;
118
119 float ang=(((start_ang<=end_ang)?start_ang:end_ang)*(M_PI/180));
120 float range=(((end_ang>start_ang)?end_ang:start_ang)*(M_PI/180));
121 float x=(rad*cos(ang));
122 float y=(rad*sin(ang));
123 do
124 {
125 coords.push_back(std::make_tuple((int)(x_cen+x+0.5),(int)(y_cen-y+0.5)));
126 ang+=0.001;
127 x=(rad*cos(ang));
128 y=(rad*sin(ang));
129 }
130 while(ang<=range);
131
132 std::tuple<int,int> co1=coords.front();
133 std::tuple<int,int> co2=coords.back();
134
135 draw_line_coords(x_cen,y_cen,std::get<0>(co1),std::get<1>(co1),coords);
137
138 for (auto & e : coords) {
139 image[get_index(std::get<0>(e),std::get<1>(e),width)]=color;
140 }
141 }
142
143 void draw_filled_wedge(int x_cen,int y_cen,int rad,int start_ang,int end_ang,std::ve\
144 ctor<std::tuple<float, float, float>> &image,std::tuple<float, float, float> &color,
145 int width, int height)
146 {
148
153 do
154 {
156 ang+=0.001;
159 }
161
164
167
168 std::vector<int> ys;
169 std::vector<int> xs;
170 get_all_ys(ys,coords);
171 std::vector<std::tuple<int,int,int,int>> lines;
172
173 for (int search=0;search<=ys.size();++search)
174 {
176 if (std::get<1>(c) == ys[search]) {
177 xs.push_back(std::get<0>(c));
178 }
179 }
180 sort(xs.begin(), xs.end());
181 lines.push_back(std::make_tuple(xs.front(),ys[search],xs.back(),ys[search]));
182 xs.clear();
183 }
184
186 {
187 for (int i = sx; i <= ex; i++)
189 };
190
191 for (auto& l : lines) {
192 drawline(std::get<0>(l),std::get<2>(l),std::get<1>(l));
193 }
194 }
195
198 {
203 {
204 color=image[i];
207 }
208 out.close();
209 }
210
211 int main()
212 {
213 int width=640;
214 int height=360;
215
218
221
222 int x_cen,y_cen,rad,start_ang,end_ang;
223 x_cen=width/2;
224 y_cen=height/2;
225 rad=y_cen*0.8;
226 start_ang=0;
227 end_ang=348;
228 image[get_index(x_cen,y_cen, width)]=color;
229 draw_filled_wedge(x_cen,y_cen,rad,start_ang,end_ang,image,color,width,height);
230 color=std::make_tuple(0.5f,0.5f,0.5f);
231 draw_filled_wedge(x_cen,y_cen,rad/2,start_ang,end_ang,image,color,width,height);
233 draw_wedge(x_cen,y_cen,rad,start_ang,end_ang,image,color,width,height);
234
235 save_image(image,width,height,"12_wedge.ppm");
236
237 return 0;
238 }
13_triangles.cpp - 6504 bytes.
1 // Compile: clang++ -std=c++17 13_triangles.cpp -o 13_triangles

2
5 #include <tuple>
6 #include <vector>
7 #include <random>
8 #include <cmath>
9
11 {
13 }
14
16 {
18 }
19
22 {
26 }
27 }
28 }
29
30 void draw_line(int x1, int y1, int x2, int y2, std::vector<std::tuple<float, float, \
31 float>> &image, std::tuple<float,float,float> &color, int width, int height)
32 {
34 dx = x2 - x1; dy = y2 - y1;
35 if (dx == 0)
36 {
37 if (y2 < y1) std::swap(y1, y2);
38 for (y = y1; y <= y2; y++)
40 return;
41 }
42 if (dy == 0)
43 {
44 if (x2 < x1) std::swap(x1, x2);
45 for (x = x1; x <= x2; x++)
47 return;
48 }
50 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
51 if (dy1 <= dx1)
52 {
53 if (dx >= 0)
54 {
55 x = x1; y = y1; xe = x2;
56 }
57 else
58 {
59 x = x2; y = y2; xe = x1;
60 }
62 for (i = 0; x<xe; i++)
63 {
64 x = x + 1;
65 if (px<0)
66 px = px + 2 * dy1;
67 else
68 {
70 px = px + 2 * (dy1 - dx1);
71 }
73 }
74 }
75 else
76 {
77 if (dy >= 0)
78 {
79 x = x1; y = y1; ye = y2;
80 }
81 else
82 {
83 x = x2; y = y2; ye = y1;
84 }
86 for (i = 0; y<ye; i++)
87 {
88 y = y + 1;
89 if (py <= 0)
90 py = py + 2 * dx1;
91 else
92 {
94 py = py + 2 * (dx1 - dy1);
95 }
97 }
98 }
99 }
100
101 void draw_triangle(int x1, int y1, int x2, int y2, int x3, int y3, std::vector<std::\
102 tuple<float, float, float>> &image, std::tuple<float,float,float> &color, int width,
103 int height)
104 {
105 draw_line(x1, y1, x2, y2, image, color, width, height);
108 }
109
110 void draw_filled_triangle(int x1, int y1, int x2, int y2, int x3, int y3, std::vecto\
111 r<std::tuple<float, float, float>> &image, std::tuple<float,float,float> &color, int
112 width, int height)
113 {
114 auto SWAP = [](int &x, int &y) { int t = x; x = y; y = t; };
115 auto drawline = [&](int sx, int ex, int ny) { for (int i = sx; i <= ex; i++) image[\
116 get_index(i,ny,width)]=color;};
117
118 int t1x, t2x, y, minx, maxx, t1xp, t2xp;
119 bool changed1 = false;
121 int signx1, signx2, dx1, dy1, dx2, dy2;
122 int e1, e2;
123 if (y1>y2) { SWAP(y1, y2); SWAP(x1, x2); }
126
127 t1x = t2x = x1; y = y1;
128 dx1 = (int)(x2 - x1); if (dx1<0) { dx1 = -dx1; signx1 = -1; }
129 else signx1 = 1;
130 dy1 = (int)(y2 - y1);
131
134 dy2 = (int)(y3 - y1);
135
136 if (dy1 > dx1) {
137 SWAP(dx1, dy1);
138 changed1 = true;
139 }
140 if (dy2 > dx2) {
141 SWAP(dy2, dx2);
143 }
144
145 e2 = (int)(dx2 >> 1);
146 if (y1 == y2) goto next;
147 e1 = (int)(dx1 >> 1);
148
149 for (int i = 0; i < dx1;) {
150 t1xp = 0; t2xp = 0;
151 if (t1x<t2x) { minx = t1x; maxx = t2x; }
152 else { minx = t2x; maxx = t1x; }
153 while (i<dx1) {
154 i++;
155 e1 += dy1;
156 while (e1 >= dx1) {
157 e1 -= dx1;
158 if (changed1) t1xp = signx1;

159 else goto next1;
160 }
161 if (changed1) break;
162 else t1x += signx1;
163 }
164 next1:
165 while (1) {
166 e2 += dy2;
167 while (e2 >= dx2) {
168 e2 -= dx2;
171 }
174 }
175 next2:
176 if (minx>t1x) minx = t1x;
178 if (maxx<t1x) maxx = t1x;
180 drawline(minx, maxx, y);
181 if (!changed1) t1x += signx1;
182 t1x += t1xp;
184 t2x += t2xp;
185 y += 1;
186 if (y == y2) break;
187
188 }
189 next:
192 dy1 = (int)(y3 - y2);
193 t1x = x2;
194
195 if (dy1 > dx1) {
196 SWAP(dy1, dx1);
198 }
199 else changed1 = false;
200
201 e1 = (int)(dx1 >> 1);

202
203 for (int i = 0; i <= dx1; i++) {
204 t1xp = 0; t2xp = 0;
207 while (i<dx1) {
208 e1 += dy1;
209 while (e1 >= dx1) {
210 e1 -= dx1;
211 if (changed1) { t1xp = signx1; break; }
213 }
216 if (i<dx1) i++;
217 }
218 next3:
219 while (t2x != x3) {
220 e2 += dy2;
221 while (e2 >= dx2) {
222 e2 -= dx2;
225 }
228 }
229 next4:
230
237 t1x += t1xp;
239 t2x += t2xp;
240 y += 1;
241 if (y>y3) return;
242 }
243 }
244
247 {
252 {
253 color=image[i];
256 }
257 out.close();
258 }
259
260 int main()
261 {
262 int width=640;
263 int height=360;
264 int x11=0,x12=0,x13=0,x21=0,x22=0,x23=0,y1=0,y2=0;
265
266 x11=((width-(((height/2)*0.8)*3))/2)+(((height/2)*0.8)/2);
267 x12=x11+(((height/2)*0.8)/2);
268 x13=x11-(((height/2)*0.8)/2);
269 x21=width-x11;
270 x22=x21+(((height/2)*0.8)/2);
271 x23=x21-(((height/2)*0.8)/2);
272 y1=(height-((height/2)*0.8))/2;
273 y2=y1+((height/2)*0.8);
274
277
280
282 draw_triangle(x11,y1,x12,y2,x13,y2,image,color,width,height);
283 draw_filled_triangle(x21,y1,x22,y2,x23,y2,image,color,width,height);
284
285 save_image(image,width,height,"13_trangles.ppm");
286
287 return 0;
288 }
1 b 576 720 0.694118 0.552941 0.509804

2 t 175 285 417 440 0.341176 0 0.0117647 0.501961
3 t 419 0 575 388 0.862745 0.980392 0.945098 0.501961
4 t 202 60 236 247 1 1 1 0.501961
5 t 372 110 391 427 0.258824 0 0 0.501961
6 t 0 0 92 558 0.937255 0.862745 0.784314 0.501961
7 t 130 585 518 719 0.482353 0.262745 0.235294 0.501961
8 t 76 36 202 415 0.898039 0.32549 0.231373 0.501961
9 t 233 177 339 221 0.376471 0.180392 0.0823529 0.501961
10 t 327 308 424 385 0.254902 0.00784314 0.113725 0.501961
11 t 52 409 132 538 0.905882 0.882353 0.862745 0.501961
12 t 210 118 258 177 1 1 0.996078 0.501961
13 t 232 36 277 113 0.780392 0.172549 0.0980392 0.501961
14 t 433 521 551 634 0.72549 0.203922 0.141176 0.501961
15 t 148 128 166 225 0.980392 0.956863 0.921569 0.501961
16 t 169 150 182 218 0 0 0.117647 0.501961
17 t 130 429 287 639 0.627451 0.690196 0.67451 0.501961
18 t 311 47 373 118 0.737255 0.219608 0.152941 0.501961
19 t 274 210 304 255 1 1 0.984314 0.501961
20 t 121 312 207 451 0.819608 0.290196 0.215686 0.501961
21 t 348 145 375 240 0.972549 0.901961 0.803922 0.501961
22 t 367 230 412 418 0.494118 0.129412 0.121569 0.501961
23 t 348 0 422 59 0.741176 0.854902 0.835294 0.501961
24 t 303 295 333 327 0.968627 0.8 0.682353 0.501961
25 t 283 381 348 541 0.392157 0.411765 0.368627 0.501961
26 t 187 246 208 288 0.235294 0 0.0431373 0.501961
27 t 406 390 487 535 0.470588 0.666667 0.694118 0.501961
28 t 191 64 240 109 1 0.905882 0.890196 0.501961
29 t 219 313 248 373 0.054902 0 0.101961 0.501961
30 t 358 272 376 340 0 0 0.180392 0.501961
31 t 316 126 356 166 0.882353 0.929412 0.882353 0.501961
32 t 544 187 575 388 0.572549 0.490196 0.47451 0.501961
33 t 0 459 32 557 0.588235 0.392157 0.364706 0.501961
34 t 412 144 515 326 0.858824 0.862745 0.811765 0.501961
35 t 178 114 206 151 0.482353 0.0235294 0.0745098 0.501961
36 t 318 377 373 447 0.501961 0.0705882 0.0588235 0.501961
37 t 58 70 152 190 0.847059 0.360784 0.247059 0.501961

38 t 213 246 261 297 0.972549 0.67451 0.505882 0.501961
39 t 199 143 225 243 1 1 0.941176 0.501961
40 t 322 317 357 374 0 0 0.235294 0.501961
41 t 240 391 307 439 0.529412 0.568627 0.537255 0.501961
42 t 406 256 421 416 0.709804 0.278431 0.254902 0.501961
43 t 219 195 272 205 0.231373 0.0470588 0 0.501961
44 t 325 275 352 300 0.968627 0.819608 0.698039 0.501961
45 t 388 0 437 149 0.709804 0.729412 0.717647 0.501961
46 t 518 447 575 555 0.721569 0.329412 0.286275 0.501961
47 t 0 268 102 397 0.792157 0.823529 0.768627 0.501961
48 t 290 52 306 94 1 0.905882 0.964706 0.501961
49 t 279 477 392 607 0.545098 0.607843 0.54902 0.501961
50 t 315 192 354 201 0 0 0 0.501961
51 t 350 597 452 686 0.666667 0.207843 0.14902 0.501961
52 t 264 67 288 109 0.439216 0.12549 0.0823529 0.501961
53 t 374 127 389 186 0.0823529 0 0.101961 0.501961
54 t 272 657 304 680 0.92549 0.890196 0.627451 0.501961
55 t 143 180 153 257 1 0.933333 0.831373 0.501961
56 t 369 438 448 557 0.623529 0.682353 0.662745 0.501961
57 t 0 0 31 241 0.866667 0.901961 0.858824 0.501961
58 t 162 105 173 156 0.917647 0.92549 0.823529 0.501961
59 t 275 281 311 293 0.286275 0 0 0.501961
60 t 267 238 277 283 1 1 0.917647 0.501961
61 t 243 259 309 269 0.611765 0.160784 0.0901961 0.501961
62 t 355 207 369 252 0.952941 1 0.929412 0.501961
63 t 274 100 305 213 0.529412 0.470588 0.447059 0.501961
64 t 30 0 137 43 0.92549 0.8 0.701961 0.501961
65 t 171 136 194 184 0.415686 0.00392157 0.235294 0.501961
66 t 460 350 553 426 0.741176 0.729412 0.686275 0.501961
67 t 240 296 304 325 0.803922 0.392157 0.298039 0.501961
68 t 167 231 182 300 0.847059 0.607843 0.756863 0.501961
69 t 24 513 126 593 0.721569 0.67451 0.686275 0.501961
70 t 389 205 412 303 0.709804 0.313726 0.282353 0.501961
71 t 215 679 342 719 0.490196 0.2 0.164706 0.501961
72 t 362 101 381 137 0.427451 0.054902 0.0627451 0.501961
73 t 81 622 246 719 0.458824 0.443137 0.45098 0.501961
74 t 49 419 146 503 0.866667 0.807843 0.764706 0.501961
75 t 0 0 574 18 0.819608 0.788235 0.737255 0.501961
76 t 347 294 364 354 0 0 0.152941 0.501961
77 t 274 35 291 54 1 0.882353 0.921569 0.501961
78 t 231 211 243 307 0.901961 0.615686 0.462745 0.501961
79 t 406 561 492 656 0.678431 0.266667 0.207843 0.501961
80 t 111 333 145 399 0.788235 0.223529 0.0392157 0.501961

81 t 314 195 335 210 0 0 0.0235294 0.501961
82 t 366 245 384 308 0.121569 0.0156863 0.176471 0.501961
83 t 343 239 361 281 0.988235 0.788235 0.658824 0.501961
84 t 235 117 266 147 1 0.988235 0.905882 0.501961
85 t 127 429 220 442 0.639216 0.239216 0.231373 0.501961
86 t 166 203 175 232 0.172549 0 0.184314 0.501961
87 t 201 647 267 719 0.396078 0.282353 0.266667 0.501961
88 t 416 359 441 456 0.458824 0.52549 0.541176 0.501961
89 t 215 346 226 430 0.207843 0.0156863 0.141176 0.501961
90 t 404 138 573 197 0.74902 0.752941 0.721569 0.501961
91 t 203 120 225 133 0.835294 0.45098 0.258824 0.501961
92 t 279 204 286 254 1 1 1 0.501961
93 t 49 28 86 264 0.878431 0.6 0.478431 0.501961
94 t 468 608 575 719 0.654902 0.529412 0.47451 0.501961
95 t 225 34 268 77 0.737255 0.282353 0.278431 0.501961
96 t 196 56 215 95 1 0.984314 0.952941 0.501961
97 t 166 488 255 565 0.733333 0.760784 0.733333 0.501961
98 t 180 203 188 262 0.890196 0.686275 0.729412 0.501961
99 t 348 367 409 426 0.592157 0.176471 0.117647 0.501961
100 t 250 161 276 228 0.560784 0.301961 0.211765 0.501961
101 t 113 84 155 144 0.776471 0.270588 0.184314 0.501961
102 t 222 299 233 337 0.0196078 0 0.0588235 0.501961
103 t 0 317 39 471 0.65098 0.686275 0.662745 0.501961
104 t 386 110 396 134 1 0.835294 0.803922 0.501961
105 t 239 197 261 210 0 0.0431373 0.054902 0.501961
106 t 299 37 357 59 0.745098 0.262745 0.34902 0.501961
107 t 294 321 314 380 0.65098 0.486275 0.494118 0.501961
108 t 303 644 385 695 0.541176 0.235294 0.203922 0.501961
109 t 303 440 338 510 0.407843 0.396078 0.345098 0.501961
110 t 380 126 388 276 0.227451 0.0156863 0.0901961 0.501961
111 t 267 297 283 302 1 0.937255 1 0.501961
112 t 403 672 518 719 0.709804 0.533333 0.462745 0.501961
113 t 86 247 154 301 0.882353 0.501961 0.352941 0.501961
114 t 123 599 366 654 0.501961 0.466667 0.462745 0.501961
115 t 411 331 427 393 0.662745 0.317647 0.301961 0.501961
116 t 280 487 311 534 0.733333 0.682353 0.584314 0.501961
117 t 151 146 159 200 0.976471 1 0.92549 0.501961
118 t 246 328 285 372 0.564706 0.152941 0.0509804 0.501961
119 t 204 278 219 345 0.772549 0.356863 0.368627 0.501961
120 t 253 276 269 287 1 1 0.87451 0.501961
121 t 117 141 145 213 0.803922 0.266667 0.192157 0.501961
122 t 217 205 229 291 0.968627 0.913725 0.807843 0.501961
123 t 456 503 536 620 0.72549 0.305882 0.25098 0.501961

124 t 52 391 81 432 0.807843 0.619608 0.509804 0.501961
125 t 351 38 396 88 0.627451 0.54902 0.521569 0.501961
126 t 344 55 366 130 0.882353 0.431373 0.270588 0.501961
127 t 226 114 239 121 0.788235 0.270588 0.0745098 0.501961
128 t 314 367 339 386 0.0509804 0.00784314 0.211765 0.501961
129 t 252 303 309 313 0.552941 0.137255 0.0235294 0.501961
130 t 185 177 204 239 0.8 0.505882 0.427451 0.501961
131 t 170 167 183 205 0.160784 0 0.129412 0.501961
132 t 226 233 267 275 0.772549 0.443137 0.411765 0.501961
133 t 218 128 246 173 0.988235 1 0.988235 0.501961
134 t 84 301 109 408 0.886275 0.607843 0.470588 0.501961
135 t 318 69 335 110 0.580392 0.192157 0.0784314 0.501961
136 t 440 409 473 484 0.419608 0.564706 0.588235 0.501961
137 t 266 272 284 281 1 1 1 0.501961
138 t 382 285 391 326 0.741176 0.352941 0.32549 0.501961
139 t 551 406 575 518 0.717647 0.380392 0.341176 0.501961
140 t 390 314 404 358 0.129412 0.0117647 0 0.501961
141 t 158 173 167 269 0.788235 0.376471 0.490196 0.501961
142 t 74 423 106 453 0.94902 0.968627 0.941176 0.501961
143 t 171 94 177 116 0.980392 1 0.823529 0.501961
144 t 92 13 236 59 0.835294 0.537255 0.435294 0.501961
145 t 21 452 45 495 0.705882 0.494118 0.447059 0.501961
146 t 179 102 200 156 0.603922 0.188235 0.192157 0.501961
147 t 324 274 341 311 0.803922 0.631373 0.52549 0.501961
148 t 300 272 317 282 1 0.87451 0.780392 0.501961
149 t 254 111 276 179 0.764706 0.662745 0.584314 0.501961
150 t 397 431 408 537 0.686275 0.729412 0.709804 0.501961
151 t 365 197 373 239 0.847059 0.968627 0.917647 0.501961
152 t 289 183 304 231 0.721569 0.498039 0.458824 0.501961
153 t 391 168 401 300 0.666667 0.333333 0.317647 0.501961
154 t 301 113 328 166 0.623529 0.65098 0.654902 0.501961
155 t 268 674 299 681 0.898039 0.831373 0.623529 0.501961
156 t 526 213 575 253 0.596078 0.564706 0.54902 0.501961
157 t 230 293 238 301 1 1 0.980392 0.501961
158 t 256 290 318 296 0.329412 0 0.0392157 0.501961
159 t 494 0 575 101 0.87451 0.870588 0.827451 0.501961
160 t 285 548 320 638 0.47451 0.494118 0.454902 0.501961
161 t 152 399 212 428 0.72549 0.376471 0.380392 0.501961
162 t 201 209 240 216 1 1 0.972549 0.501961
163 t 306 309 327 338 0.776471 0.619608 0.588235 0.501961
164 t 273 225 288 252 1 1 1 0.501961
165 t 279 420 320 461 0.447059 0.431373 0.352941 0.501961
166 t 256 99 333 108 0.568627 0.254902 0.152941 0.501961

167 t 531 574 575 719 0.619608 0.501961 0.454902 0.501961
168 t 236 320 256 381 0.313726 0.0980392 0.156863 0.501961
169 t 185 259 211 303 0.501961 0.156863 0.188235 0.501961
170 t 286 58 314 69 0.988235 0.772549 0.890196 0.501961
171 t 329 416 383 443 0.447059 0.141176 0.0862745 0.501961
172 t 438 359 542 402 0.760784 0.741176 0.686275 0.501961
173 t 203 643 275 667 0.376471 0.360784 0.380392 0.501961
174 t 161 386 172 410 0.92549 0.627451 0.584314 0.501961
175 t 312 172 342 177 0.411765 0.227451 0.12549 0.501961
176 t 384 77 426 116 0.592157 0.572549 0.580392 0.501961
177 t 431 467 443 512 0.760784 0.819608 0.815686 0.501961
178 t 361 202 367 261 0.901961 0.898039 0.807843 0.501961
179 t 335 177 375 190 0.94902 0.694118 0.529412 0.501961
180 t 139 218 148 274 0.956863 0.745098 0.65098 0.501961
181 t 239 71 248 107 0.988235 0.623529 0.454902 0.501961
182 t 204 141 223 198 0.976471 1 0.984314 0.501961
183 t 164 146 171 180 0.733333 0.443137 0.564706 0.501961
184 t 369 98 377 163 0.419608 0.180392 0.219608 0.501961
185 t 151 47 166 116 0.784314 0.317647 0.211765 0.501961
186 t 289 231 311 257 0.956863 0.682353 0.647059 0.501961
187 t 243 307 253 313 0.972549 0.886275 0.741176 0.501961
188 t 39 493 51 533 0.886275 0.890196 0.87451 0.501961
189 t 274 346 295 390 0.682353 0.403922 0.317647 0.501961
190 t 450 484 491 546 0.635294 0.513726 0.482353 0.501961
191 t 194 161 228 175 0.933333 0.94902 0.937255 0.501961
192 t 325 508 351 543 0.443137 0.415686 0.368627 0.501961
193 t 448 576 480 624 0.631373 0.184314 0.133333 0.501961
194 t 148 264 159 342 0.866667 0.313726 0.137255 0.501961
195 t 316 533 331 558 0.780392 0.764706 0.666667 0.501961
196 t 0 218 59 403 0.760784 0.784314 0.752941 0.501961
197 t 12 318 46 325 0.52549 0.505882 0.478431 0.501961
198 t 400 149 415 185 0.905882 0.792157 0.768627 0.501961
199 t 220 293 226 309 0.117647 0 0.054902 0.501961
200 t 486 415 547 481 0.647059 0.576471 0.564706 0.501961
201 t 229 357 232 403 0.803922 0.458824 0.47451 0.501961
202 t 318 215 341 230 0.529412 0.278431 0.211765 0.501961
203 t 372 324 383 351 0.678431 0.219608 0.141176 0.501961
204 t 309 329 323 407 0.352941 0.215686 0.384314 0.501961
205 t 339 305 374 335 0.117647 0.00784314 0.211765 0.501961
206 t 0 264 16 327 0.839216 0.890196 0.854902 0.501961
207 t 260 197 279 216 0.576471 0.192157 0.0745098 0.501961
208 t 280 280 306 285 0.537255 0.0235294 0.0196078 0.501961
209 t 207 205 224 252 0.956863 0.976471 0.929412 0.501961

210 t 181 75 233 87 0.92549 0.796078 0.807843 0.501961
211 t 341 285 355 290 1 0.85098 0.835294 0.501961
212 t 203 233 210 249 0.854902 0.556863 0.333333 0.501961
213 t 200 363 214 401 0.45098 0.0862745 0.196078 0.501961
214 t 416 192 433 266 0.898039 0.898039 0.847059 0.501961
215 t 279 469 294 497 0.784314 0.745098 0.607843 0.501961
216 t 234 312 245 337 0.137255 0 0.0588235 0.501961
217 t 246 80 268 109 0.843137 0.301961 0.101961 0.501961
218 t 277 659 288 666 1 1 0.941176 0.501961
219 t 237 302 245 308 0.988235 0.972549 0.905882 0.501961
220 t 391 126 400 148 1 0.803922 0.760784 0.501961
221 t 406 529 459 572 0.662745 0.509804 0.470588 0.501961
222 t 183 92 188 124 0.478431 0.0980392 0.0705882 0.501961
223 t 328 135 365 167 0.87451 0.819608 0.741176 0.501961
224 t 191 101 206 123 0.909804 0.560784 0.478431 0.501961
225 t 231 178 239 193 1 0.772549 0.501961 0.501961
226 t 339 200 350 298 0.796078 0.607843 0.552941 0.501961
227 t 442 655 521 671 0.733333 0.509804 0.439216 0.501961
228 t 10 336 41 357 0.639216 0.623529 0.580392 0.501961
229 t 168 402 192 456 0.741176 0.313726 0.282353 0.501961
230 t 10 574 163 668 0.647059 0.572549 0.537255 0.501961
231 t 274 677 283 691 0.388235 0.168627 0.184314 0.501961
232 t 81 178 139 229 0.835294 0.360784 0.27451 0.501961
233 t 310 694 436 719 0.694118 0.419608 0.34902 0.501961
234 t 180 286 222 304 0.623529 0.239216 0.235294 0.501961
235 t 178 86 183 96 0.929412 1 0.815686 0.501961
236 t 331 632 437 678 0.615686 0.25098 0.2 0.501961
237 t 286 250 296 276 0.701961 0.305882 0.239216 0.501961
238 t 240 37 269 51 0.529412 0.176471 0.184314 0.501961
239 t 206 53 220 121 0.984314 0.898039 0.823529 0.501961
240 t 544 526 575 606 0.721569 0.529412 0.458824 0.501961
241 t 291 0 349 32 0.647059 0.682353 0.658824 0.501961
242 t 364 266 383 299 0.2 0.0313726 0.180392 0.501961
243 t 155 138 161 180 0.980392 1 0.905882 0.501961
244 t 504 661 548 719 0.635294 0.592157 0.568627 0.501961
245 t 201 439 237 490 0.670588 0.678431 0.654902 0.501961
246 t 242 220 272 240 0.713726 0.305882 0.34902 0.501961
247 t 3 113 38 191 0.929412 0.858824 0.788235 0.501961
248 t 186 126 211 136 0.627451 0.192157 0.129412 0.501961
249 t 353 363 362 378 0.729412 0.352941 0.360784 0.501961
250 t 518 117 575 208 0.713726 0.698039 0.658824 0.501961
251 t 266 316 304 329 0.72549 0.498039 0.439216 0.501961
252 t 268 401 301 417 0.607843 0.580392 0.6 0.501961

253 t 235 423 273 502 0.627451 0.623529 0.533333 0.501961
254 t 0 701 8 719 0.972549 0.803922 0.741176 0.501961
255 t 294 653 299 658 1 1 0.890196 0.501961
256 t 167 208 170 250 0.411765 0.129412 0.219608 0.501961
257 t 267 250 272 261 1 1 1 0.501961
258 t 111 67 153 161 0.803922 0.345098 0.258824 0.501961
259 t 191 242 199 273 0.282353 0.0823529 0.156863 0.501961
260 t 301 471 324 497 0.403922 0.384314 0.321569 0.501961
261 t 232 357 258 411 0.458824 0.211765 0.258824 0.501961
262 t 18 52 103 79 0.886275 0.647059 0.529412 0.501961
263 t 448 97 481 172 0.831373 0.85098 0.815686 0.501961
264 t 265 136 309 183 0.498039 0.486275 0.47451 0.501961
265 t 277 61 285 103 0.419608 0.184314 0.192157 0.501961
266 t 215 261 241 281 0.87451 0.670588 0.478431 0.501961
267 t 270 626 341 654 0.458824 0.364706 0.345098 0.501961
268 t 225 306 238 316 0.129412 0 0.0431373 0.501961
269 t 4 0 98 10 0.858824 0.87451 0.862745 0.501961
270 t 299 659 308 669 0.968627 0.847059 0.462745 0.501961
271 t 351 189 362 201 0.870588 0.447059 0.32549 0.501961
272 t 165 114 171 128 0.996078 1 0.921569 0.501961
273 t 430 449 436 470 0.764706 0.890196 0.909804 0.501961
274 t 188 130 196 164 0.427451 0.0431373 0.109804 0.501961
275 t 329 554 341 573 0.780392 0.788235 0.733333 0.501961
276 t 28 520 120 568 0.756863 0.670588 0.670588 0.501961
277 t 58 301 88 343 0.901961 0.827451 0.756863 0.501961
278 t 12 200 37 284 0.721569 0.713726 0.670588 0.501961
279 t 406 18 495 78 0.780392 0.792157 0.756863 0.501961
280 t 384 101 390 116 1 0.729412 0.709804 0.501961
281 t 428 267 523 340 0.870588 0.886275 0.831373 0.501961
282 t 242 377 248 400 0.823529 0.45098 0.364706 0.501961
283 t 371 238 387 262 0.235294 0.0941176 0.0823529 0.501961
284 t 259 50 276 79 0.576471 0.313726 0.368627 0.501961
285 t 226 287 233 294 1 1 0.945098 0.501961
286 t 249 313 255 317 1 0.972549 0.862745 0.501961
287 t 347 449 373 529 0.568627 0.607843 0.564706 0.501961
288 t 93 413 124 422 0.945098 0.894118 0.831373 0.501961
289 t 489 442 509 456 0.803922 0.403922 0.341176 0.501961
290 t 247 293 263 309 0.615686 0.231373 0.0235294 0.501961
291 t 536 467 555 548 0.698039 0.341176 0.298039 0.501961
292 t 305 517 319 533 0.788235 0.756863 0.654902 0.501961
293 t 71 370 104 410 0.847059 0.572549 0.458824 0.501961
294 t 112 418 151 430 0.831373 0.631373 0.588235 0.501961
295 t 144 380 151 402 0.964706 0.596078 0.490196 0.501961

296 t 530 196 555 393 0.745098 0.709804 0.666667 0.501961
297 t 319 322 332 344 0.368627 0.254902 0.411765 0.501961
298 t 179 212 183 228 0.964706 0.858824 0.87451 0.501961
299 t 293 437 302 480 0.376471 0.372549 0.290196 0.501961
300 t 309 312 323 323 0.988235 0.796078 0.67451 0.501961
301 t 125 559 168 716 0.552941 0.47451 0.482353 0.501961
302 t 334 382 419 408 0.580392 0.188235 0.164706 0.501961
303 t 472 64 516 114 0.72549 0.733333 0.698039 0.501961
304 t 171 164 180 216 0.231373 0 0.152941 0.501961
305 t 355 289 368 348 0.113725 0.00392157 0.164706 0.501961
306 t 144 200 154 229 0.960784 0.905882 0.815686 0.501961
307 t 185 189 188 206 0.878431 0.835294 0.878431 0.501961
308 t 342 71 375 87 0.870588 0.54902 0.431373 0.501961
309 t 288 373 308 407 0.380392 0.380392 0.482353 0.501961
310 t 241 170 256 180 0.882353 0.576471 0.32549 0.501961
311 t 339 29 368 47 0.576471 0.607843 0.596078 0.501961
312 t 226 562 280 615 0.615686 0.623529 0.611765 0.501961
313 t 25 44 52 116 0.913725 0.72549 0.607843 0.501961
314 t 107 349 147 391 0.784314 0.278431 0.145098 0.501961
315 t 563 193 575 264 0.533333 0.505882 0.505882 0.501961
316 t 278 36 294 57 1 0.729412 0.745098 0.501961
317 t 407 423 439 451 0.415686 0.552941 0.568627 0.501961
318 t 56 284 65 304 0.635294 0.568627 0.529412 0.501961
319 t 488 594 502 621 0.792157 0.490196 0.427451 0.501961
320 t 349 580 392 613 0.627451 0.490196 0.45098 0.501961
321 t 317 201 334 207 0 0 0 0.501961
322 t 384 142 390 213 0.223529 0.0431373 0.133333 0.501961
323 t 268 287 321 293 0.270588 0.0313726 0.0235294 0.501961
324 t 131 271 148 347 0.87451 0.494118 0.345098 0.501961
325 t 302 189 318 218 0.431373 0.258824 0.309804 0.501961
326 t 151 407 163 420 0.866667 0.631373 0.580392 0.501961
327 t 409 167 416 208 0.898039 0.866667 0.831373 0.501961
328 t 118 432 169 438 0.682353 0.290196 0.227451 0.501961
329 t 174 227 190 253 0.862745 0.556863 0.611765 0.501961
330 t 443 463 481 489 0.454902 0.513726 0.521569 0.501961
331 t 232 120 272 129 0.933333 0.92549 0.87451 0.501961
332 t 81 308 112 344 0.866667 0.662745 0.564706 0.501961
333 t 210 703 319 719 0.580392 0.254902 0.211765 0.501961
334 t 309 276 323 285 0.960784 0.776471 0.678431 0.501961
335 t 79 464 160 515 0.792157 0.737255 0.698039 0.501961
336 t 283 293 300 303 0.796078 0.0392157 0.309804 0.501961
337 t 0 374 21 484 0.662745 0.631373 0.596078 0.501961
338 t 270 670 274 682 1 1 0.733333 0.501961

339 t 362 351 374 365 0.729412 0.231373 0.176471 0.501961
340 t 406 250 416 334 0.643137 0.294118 0.27451 0.501961
341 t 56 442 92 467 0.913725 0.909804 0.886275 0.501961
342 t 480 541 537 588 0.717647 0.258824 0.2 0.501961
343 t 361 45 387 66 0.529412 0.556863 0.576471 0.501961
344 t 350 203 358 285 0.882353 0.737255 0.662745 0.501961
345 t 219 45 237 65 0.913725 0.392157 0.301961 0.501961
346 t 312 245 332 276 0.670588 0.431373 0.403922 0.501961
347 t 176 108 183 129 0.729412 0.411765 0.360784 0.501961
348 t 147 0 299 28 0.74902 0.596078 0.529412 0.501961
349 t 201 408 210 423 0.705882 0.568627 0.556863 0.501961
350 t 153 216 162 274 0.894118 0.423529 0.415686 0.501961
351 t 287 670 295 674 0.384314 0.160784 0.113725 0.501961
352 t 0 499 20 560 0.67451 0.470588 0.423529 0.501961
353 t 159 418 174 435 0.65098 0.203922 0.141176 0.501961
354 t 291 36 329 47 0.858824 0.329412 0.313726 0.501961
355 t 338 535 356 559 0.47451 0.462745 0.411765 0.501961
356 t 292 493 305 515 0.776471 0.752941 0.65098 0.501961
357 t 270 268 279 280 0.972549 1 0.964706 0.501961
358 t 184 174 186 193 0.219608 0.0941176 0.27451 0.501961
359 t 294 678 297 685 1 1 0.87451 0.501961
360 t 386 75 401 102 0.501961 0.47451 0.498039 0.501961
361 t 361 278 365 288 0 0 0 0.501961
362 t 390 577 437 614 0.670588 0.341176 0.301961 0.501961
363 t 176 95 179 104 1 1 0.905882 0.501961
364 t 344 301 354 369 0.101961 0.0117647 0.152941 0.501961
365 t 69 110 100 246 0.847059 0.501961 0.411765 0.501961
366 t 108 443 125 473 0.894118 0.878431 0.839216 0.501961
367 t 333 87 378 106 0.827451 0.360784 0.227451 0.501961
368 t 163 268 171 328 0.839216 0.529412 0.568627 0.501961
369 t 253 332 301 349 0.596078 0.219608 0.117647 0.501961
370 t 380 343 397 373 0.282353 0.0627451 0.0196078 0.501961
371 t 332 284 344 305 0.854902 0.666667 0.6 0.501961
372 t 375 199 385 228 0.6 0.258824 0.184314 0.501961
373 t 561 373 575 447 0.745098 0.443137 0.403922 0.501961
374 t 17 360 73 375 0.87451 0.85098 0.792157 0.501961
375 t 267 300 277 305 0.917647 0.647059 0.643137 0.501961
376 t 332 208 344 235 0.607843 0.423529 0.388235 0.501961
377 t 2 286 51 314 0.839216 0.858824 0.819608 0.501961
378 t 170 369 178 391 0.913725 0.517647 0.482353 0.501961
379 t 115 323 134 404 0.792157 0.290196 0.145098 0.501961
380 t 34 128 72 193 0.890196 0.682353 0.572549 0.501961
381 t 278 214 287 248 1 1 0.960784 0.501961

382 t 276 260 285 268 0.545098 0.105882 0.0156863 0.501961
383 t 373 121 386 143 0.2 0.0509804 0.152941 0.501961
384 t 366 221 368 253 0.870588 0.941176 0.862745 0.501961
385 t 389 268 394 316 0.686275 0.439216 0.411765 0.501961
386 t 313 116 346 130 0.701961 0.682353 0.643137 0.501961
387 t 285 507 298 604 0.576471 0.568627 0.537255 0.501961
388 t 194 363 204 412 0.643137 0.196078 0.247059 0.501961
389 t 217 130 229 193 0.968627 0.984314 0.941176 0.501961
390 t 339 201 377 209 0.815686 0.772549 0.72549 0.501961
391 t 28 592 110 652 0.701961 0.607843 0.552941 0.501961
392 t 279 79 313 82 0.882353 0.65098 0.603922 0.501961
393 t 68 345 84 428 0.862745 0.670588 0.572549 0.501961
394 t 426 395 450 428 0.470588 0.639216 0.666667 0.501961
395 t 237 197 250 206 0 0.027451 0.0235294 0.501961
396 t 221 62 231 86 0.952941 0.65098 0.729412 0.501961
397 t 285 303 305 307 0.372549 0 0 0.501961
398 t 396 212 408 300 0.6 0.282353 0.25098 0.501961
399 t 130 34 197 67 0.780392 0.447059 0.360784 0.501961
400 t 221 295 228 384 0.2 0.0901961 0.152941 0.501961
401 t 248 178 285 198 0.603922 0.380392 0.254902 0.501961
402 t 217 198 230 204 0.819608 0.392157 0.192157 0.501961
403 t 302 296 311 298 0.992157 0.831373 0.909804 0.501961
404 t 318 506 329 523 0.384314 0.352941 0.294118 0.501961
405 t 180 133 185 170 0.741176 0.160784 0.360784 0.501961
406 t 299 267 309 280 0.92549 0.780392 0.705882 0.501961
407 t 442 62 460 88 0.866667 0.882353 0.847059 0.501961
408 t 271 657 278 661 0.266667 0.192157 0.219608 0.501961
409 t 245 281 258 290 0.94902 0.788235 0.588235 0.501961
410 t 309 652 364 673 0.498039 0.309804 0.298039 0.501961
411 t 268 34 308 38 0.913725 0.54902 0.552941 0.501961
412 t 455 214 460 238 0.615686 0.635294 0.592157 0.501961
413 t 16 317 32 322 0.447059 0.411765 0.392157 0.501961
414 t 451 370 482 394 0.843137 0.819608 0.752941 0.501961
415 t 392 153 394 184 0.670588 0.164706 0.219608 0.501961
416 t 148 366 155 387 0.960784 0.584314 0.466667 0.501961
417 t 357 236 362 275 0.886275 0.768627 0.65098 0.501961
418 t 465 407 516 437 0.592157 0.635294 0.631373 0.501961
419 t 310 51 319 115 0.65098 0.388235 0.443137 0.501961
420 t 279 198 298 208 0.831373 0.568627 0.407843 0.501961
421 t 472 22 533 53 0.862745 0.870588 0.823529 0.501961
422 t 296 242 309 253 0.960784 0.882353 0.839216 0.501961
423 t 194 120 204 144 0.631373 0.223529 0.141176 0.501961
424 t 532 149 562 165 0.843137 0.835294 0.788235 0.501961

425 t 209 415 226 435 0.494118 0.227451 0.270588 0.501961
426 t 396 299 403 318 0.152941 0.121569 0.160784 0.501961
427 t 271 239 287 256 0.992157 0.976471 0.917647 0.501961
428 t 217 434 244 458 0.678431 0.67451 0.639216 0.501961
429 t 464 620 502 657 0.729412 0.392157 0.329412 0.501961
430 t 247 264 268 272 0.670588 0.329412 0.2 0.501961
431 t 201 277 212 360 0.733333 0.32549 0.305882 0.501961
432 t 211 257 213 263 1 1 1 0.501961
433 t 194 66 211 96 0.960784 0.921569 0.913725 0.501961
434 t 31 401 57 443 0.764706 0.741176 0.690196 0.501961
435 t 346 373 352 384 0.611765 0.396078 0.458824 0.501961
436 t 236 283 246 297 0.847059 0.447059 0.188235 0.501961
437 t 252 452 285 479 0.717647 0.678431 0.552941 0.501961
438 t 504 197 530 258 0.737255 0.729412 0.686275 0.501961
439 t 367 257 370 273 0.0392157 0 0.0784314 0.501961
440 t 159 121 168 143 0.968627 0.952941 0.8 0.501961
441 t 201 680 212 704 0.576471 0.494118 0.439216 0.501961
442 t 294 81 304 88 1 0.988235 0.941176 0.501961
443 t 349 296 357 303 0 0 0.0823529 0.501961
444 t 332 314 348 377 0.141176 0.0392157 0.180392 0.501961
445 t 377 677 428 694 0.72549 0.368627 0.305882 0.501961
446 t 335 191 345 197 0.054902 0.0235294 0 0.501961
447 t 183 203 186 218 0.972549 0.890196 0.85098 0.501961
448 t 209 397 214 409 0.768627 0.572549 0.529412 0.501961
449 t 442 480 446 515 0.796078 0.803922 0.772549 0.501961
450 t 298 258 305 261 0.172549 0.0392157 0.0509804 0.501961
451 t 154 69 173 100 0.780392 0.337255 0.239216 0.501961
452 t 165 315 189 373 0.858824 0.329412 0.247059 0.501961
453 t 255 316 257 321 1 0.956863 0.815686 0.501961
454 t 394 133 401 161 0.992157 0.713726 0.686275 0.501961
455 t 406 76 430 158 0.658824 0.67451 0.647059 0.501961
456 t 422 427 428 473 0.396078 0.498039 0.517647 0.501961
457 t 283 249 299 260 0.92549 0.568627 0.482353 0.501961
458 t 244 695 245 703 1 0.937255 0.792157 0.501961
459 t 328 526 334 537 0.309804 0.290196 0.243137 0.501961
460 t 21 378 35 384 0.564706 0.533333 0.486275 0.501961
461 t 363 141 371 168 0.752941 0.588235 0.537255 0.501961
462 t 302 387 330 399 0.317647 0.152941 0.27451 0.501961
463 t 7 659 91 719 0.6 0.560784 0.490196 0.501961
464 t 295 524 308 584 0.521569 0.498039 0.443137 0.501961
465 t 523 595 563 645 0.654902 0.486275 0.419608 0.501961
466 t 315 175 332 193 0.533333 0.290196 0.168627 0.501961
467 t 312 448 356 474 0.482353 0.494118 0.458824 0.501961

468 t 430 10 454 34 0.701961 0.686275 0.662745 0.501961
469 t 415 612 458 649 0.580392 0.219608 0.172549 0.501961
470 t 486 502 521 527 0.772549 0.490196 0.435294 0.501961
471 t 141 448 203 457 0.678431 0.529412 0.52549 0.501961
472 t 130 104 147 188 0.784314 0.298039 0.219608 0.501961
473 t 146 334 151 367 0.721569 0.203922 0.109804 0.501961
474 t 13 549 73 582 0.733333 0.666667 0.631373 0.501961
475 t 295 663 299 667 0.329412 0.184314 0.160784 0.501961
476 t 380 306 392 324 0.635294 0.188235 0.160784 0.501961
477 t 155 380 162 399 0.666667 0.184314 0.188235 0.501961
478 t 288 645 293 660 0.427451 0.25098 0.239216 0.501961
479 t 208 206 228 237 0.956863 0.980392 0.956863 0.501961
480 t 60 38 113 68 0.847059 0.576471 0.470588 0.501961
481 t 170 176 176 228 0.266667 0.0470588 0.192157 0.501961
482 t 203 514 264 571 0.709804 0.717647 0.686275 0.501961
483 t 299 217 311 237 0.694118 0.513726 0.592157 0.501961
484 t 9 324 31 332 0.862745 0.882353 0.831373 0.501961
485 t 275 419 316 446 0.47451 0.447059 0.384314 0.501961
486 t 127 513 169 567 0.65098 0.611765 0.588235 0.501961
487 t 380 401 401 433 0.47451 0.160784 0.156863 0.501961
488 t 265 112 283 130 0.796078 0.666667 0.611765 0.501961
489 t 235 664 265 687 0.384314 0.254902 0.258824 0.501961
490 t 19 5 34 5 0.294118 0.309804 0.294118 0.501961
491 t 305 64 312 99 0.847059 0.576471 0.592157 0.501961
492 t 186 213 202 234 0.815686 0.423529 0.317647 0.501961
493 t 15 342 25 349 0.905882 0.929412 0.882353 0.501961
494 t 381 93 386 106 1 0.670588 0.666667 0.501961
495 t 29 267 34 280 0.541176 0.521569 0.47451 0.501961
496 t 387 112 395 129 0.976471 0.772549 0.72549 0.501961
497 t 126 293 131 374 0.827451 0.341176 0.172549 0.501961
498 t 188 83 192 96 0.619608 0.321569 0.321569 0.501961
499 t 0 598 21 652 0.627451 0.513726 0.431373 0.501961
500 t 171 125 175 150 0.737255 0.454902 0.478431 0.501961
501 t 224 117 229 123 0.772549 0.388235 0.203922 0.501961
14_animation05.cpp - 6656 bytes.

1 // Compile: clang++ -std=c++17 14_animation05.cpp -o 14_animation05
2
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
10 #include <sstream>
11 #include <iomanip>
12 #include <filesystem>
13 namespace fs = std::filesystem;
14
16 {
22 return true;
23 else
24 return false;
25 }
26
28 {
30 }
31
33 {
35 }
36
39 {
43 }
44 }
45 }
46
47 std::string get_filname(int ctr)
48 {
49 std::stringstream ss;
50 ss << "anim05/" << std::setfill ('0') << std::setw(4) << ctr << "-swye05.ppm";
51
52 return ss.str();
53 }
54
57 {
62 {
63 color=image[i];
66 }
67 out.close();
68 }
69
71 {
72 size_t start;
73 size_t end = 0;
75
77 {
80 }
81
84
86 }
87
89 {
90 size_t start;
91 size_t end = 0;
93
95 {
98 }
99
103
105 }
106
109 {
115 int state=0;
117
119 {
121 state=1;
122 }
123
125 && state == 1) {
129 state=2;
130 }
131
133 state=3;
134 }
135
141 done = true;
142 }
143 }
144 infile.close();
145 }
146
147 void update_x_and_y(int r, std::tuple<int,int> &walk1, std::tuple<int,int> &walk2, i\
148 nt width, int height)
149 {
150 int x1,y1,x2,y2;
153
154 switch(r) {
155 case 0:
156 x1+=1;
157 x2-=1;
158 break;
159 case 1:
160 x1-=1;
161 x2+=1;
162 break;
163 case 2:
164 y1+=1;
165 y2-=1;
166 break;
167 case 3:
168 y1-=1;
169 y2+=1;
170 break;
171 }
172
173 if (x1 < 0) {
174 x1 = 0;
176 x1=width-1;
177 }
178
179 if (x2 < 0) {
180 x2 = 0;
182 x2=width-1;
183 }
184
185 if (y1 < 0) {
186 y1 = 0;
188 y1 = height-1;
189 }
190
191 if (y2 < 0) {
192 y2 = 0;
194 y2 = height-1;
195 }
196
199 }
200
203 {
207

216 }
217 }
218 }
219
220 void walker(std::vector<std::tuple<float, float, float>> &image1, std::vector<std::t\
221 uple<float, float, float>> &image2, int width, int height)
222 {
223 // Randomize and draw walkers
225 int x1=width/2;
227 int x2=width/2;
229
231 std::mt19937 mt(rd());
232 std::uniform_int_distribution<> dist(0, 3);
233
236
237 int ctr=0;
238 std::string fn="";
239 fn=get_filname(ctr++);
240 std::cout << fn << std::endl;
241 save_image(image2,width,height,fn);
242
243 int r=0;
244 for (int i=0;i<100000;++i) {
245 r=dist(mt);
246 update_x_and_y(r,walk1,walk2,width,height);
251 if (i%100 == 0) {
254 save_image(image2,width,height,fn);
255 }
256 }
257 }
258
259 int main()
260 {
261 fs::create_directory("anim05");
265 int width=0;
266 int height=0;
267
268 read_image(image1, width, height, "ppm/04_helloworld.ppm");
269
271 clear_image(image2,color,width,height);
272 blended_two_images(image2,image1,width,height,0.2);
273 // Random Walker
274 walker(image1,image2,width,height);
275
276 // ffmpeg -framerate 15 -i %4d-swye05.ppm -c:v libx264 -r 30 swye05.mp4
277
278 return 0;
279 }

2
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
14
16 {

22 return true;
23 else
24 return false;
25 }
26
28 {
30 }
31
33 {
35 }
36
38 at,float,float> &colorRGB, int width, int height)
39 {
42 image[get_index(x,y,width)]=colorRGB;
43 }
44 }
45 }
46
49 {
50 size_t start;
51 size_t end = 0;
53
55 {
58 }
59
65
67 }
68
69 std::tuple<int,int,int,int,float,float,float,float> parse_rect_line(const std::strin\
70 g str)
71 {
72 size_t start;
73 size_t end = 0;
75
77 {
80 }
81
90
92 }
93
96 {
104

106 }
107
108 void draw_filled_rect(int x1,int y1,int x2,int y2, std::vector<std::tuple<float, flo\
109 at, float>> &image, std::tuple<float,float,float,float> &colorRGBA, int width, int h
110 eight)
111 {
112 for (int i = y1; i < y2; i++) {
113 for (int j = x1; j < x2; j++) {
114 image[get_index(j,i,width)]=blend_colors(image[get_index(j,i,width)],colorRG
115 }
116 }
117 }
118
120 {
123
124 return ss.str();
125 }
126
129 {
134 {
135 color=image[i];
138 }
139 out.close();
140 }
141
142 int main()
143 {
147 std::tuple<int,int,int,int,float,float,float,float> rect;

155 int ctr=0;
158 {
159 if (startsWithCaseInsensitive(line,"r")) {
160 rect=parse_rect_line(line);
161 std::tie(x1,y1,x2,y2,rf,gf,bf,af) = rect;
163 draw_filled_rect(x1,y1,x2,y2,image,colorRGBA,width,height);
166 save_image(image,width,height,fn);
167 }
168
178 }
179 }
180 infile.close();
181
183
184 return 0;
185 }

2
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
14
16 {
22 return true;
23 else
24 return false;
25 }
26
28 {
30 }
31
33 {
35 }
36
39 {
43 }
44 }
45 }
46
47 std::tuple<int,int,int,float,float,float,float> parse_circle_line(const std::string \
48 str)
49 {
50 size_t start;
51 size_t end = 0;
53
55 {
58 }
59
60 int dx=stoi(out[1]);
61 int dy=stoi(out[2]);
67
68 return std::make_tuple(dx,dy,r,rf,gf,bf,af);
69 }
70
73 {
74 size_t start;
75 size_t end = 0;
77
79 {
82 }
83
89
91 }
92
95 {
103
105 }
106
108 {
109 int code=0;
110 if(y >= height)
111 code |= 1; //top
112 else if(y < 0)
114 if(x >= width)
116 else if (x < 0)
117 code |= 8; //left
118 return(code);
119 }
120
123 {
133 {
138 {
139 int x, y;
142 {
143 x = x1 + (x2 - x1) * (height - y1) / (y2 - y1);
144 y = height - 1;
145 }
147 {
148 x = x1 + (x2 - x1) * -y1 / (y2 - y1);
149 y = 0;
150 }
152 {
153 y = y1 + (y2 - y1) * (width - x1) / (x2 - x1);
154 x = width - 1;
155 }
156 else //left
157 {
158 y = y1 + (y2 - y1) * -x1 / (x2 - x1);
159 x = 0;
160 }
162 {
163 x1 = x; y1 = y;
165 }
167 {
168 x2 = x; y2 = y;
170 }
171 }
172 }
174 if(accept)
175 {
176 x3 = x1;
177 x4 = x2;
178 y3 = y1;
179 y4 = y2;
181 return 1;
182 }
183 else
184 {
185 x3 = x4 = y3 = y4 = 0;
187 return 0;
188 }
189 }
190
192 t, float>> &image, std::tuple<float, float, float, float> &colorRGBA, int width, int
193 height)
194 {
195 int x0 = 0;
197 int d = 3 - 2 * radius;
201
203 {
209 for (int i = sx; i <= ex; i++) {
211 RGBA);
212 }
213 }
214 };
215
216 while (y0 >= x0)
217 {
218 drawline(x - x0, x + x0, y - y0);
219 drawline(x - y0, x + y0, y - x0);
220 drawline(x - x0, x + x0, y + y0);
221 drawline(x - y0, x + y0, y + x0);
222 if (d < 0) d += 4 * x0++ + 6;
223 else d += 4 * (x0++ - y0--) + 10;
224 }
225 }
226
228 {
231
233 }
234
237 {
242 {
243 color=image[i];
246 }
247 out.close();
248 }
249
250 int main()
251 {
255 std::tuple<int,int,int,float,float,float,float> circle;

259 int width,height,xx,yy,r;
263 int ctr=0;
266 {
267 if (startsWithCaseInsensitive(line,"c")) {
268 circle=parse_circle_line(line);
269 std::tie(xx,yy,r,rf,gf,bf,af) = circle;
271 draw_filled_circle(xx,yy,r,image,colorRGBA,width,height);
275 }
285 }
286 }
287 infile.close();
288
290
291 return 0;
292 }

2
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
14
16 {
22 return true;
23 else
24 return false;
25 }
26
28 {
30 }
31
33 {
35 }
36
39 {
43 }
44 }
45 }
46
47 std::tuple<int,int,float,float,float> parse_bginfo_line(const std::string str, int w\
48 idth, int height)
49 {
50 size_t start;
51 size_t end = 0;
53
55 {
58 }
59
65
67 }
68
69 std::tuple<int,int,int,int,float,float,float,float> parse_triangle_line(const std::s\
70 tring str)
71 {
72 size_t start;
73 size_t end = 0;
75
77 {
80 }
81
90
92 }
93
96 {
104
106 }
107
109 {
110 int code=0;
111 if(y >= height)
112 code |= 1; //top
113 else if(y < 0)
115 if(x >= width)
117 else if (x < 0)
118 code |= 8; //left
119 return(code);
120 }
121
124 {

134 {
139 {
140 int x, y;
143 {
144 x = x1 + (x2 - x1) * (height - y1) / (y2 - y1);
145 y = height - 1;
146 }
148 {
149 x = x1 + (x2 - x1) * -y1 / (y2 - y1);
150 y = 0;
151 }
153 {
154 y = y1 + (y2 - y1) * (width - x1) / (x2 - x1);
155 x = width - 1;
156 }
157 else //left
158 {
159 y = y1 + (y2 - y1) * -x1 / (x2 - x1);
160 x = 0;
161 }
163 {
164 x1 = x; y1 = y;
166 }
168 {
169 x2 = x; y2 = y;
171 }
172 }
173 }
175 if(accept)
176 {
177 x3 = x1;
178 x4 = x2;
179 y3 = y1;
180 y4 = y2;
182 return 1;
183 }
184 else
185 {
186 x3 = x4 = y3 = y4 = 0;
188 return 0;
189 }
190 }
191
192 void draw_filled_triangle(int x1, int y1, int x2, int y2, int x3, int y3, std::vecto\
193 r<std::tuple<float, float, float>> &image, std::tuple<float,float,float,float> &colo
194 rRGBA, int width, int height)
195 {
200 {
206 for (int i = sx; i <= ex; i++) {
208 RGBA);
209 }
210 }
211 };
212

217 int e1, e2;
221
222 t1x = t2x = x1; y = y1;
225 dy1 = (int)(y2 - y1);
226
229 dy2 = (int)(y3 - y1);
230
231 if (dy1 > dx1) {
232 SWAP(dx1, dy1);
234 }
235 if (dy2 > dx2) {
236 SWAP(dy2, dx2);
238 }
239
240 e2 = (int)(dx2 >> 1);
242 e1 = (int)(dx1 >> 1);
243
244 for (int i = 0; i < dx1;) {
245 t1xp = 0; t2xp = 0;
248 while (i<dx1) {
249 i++;
250 e1 += dy1;
251 while (e1 >= dx1) {
252 e1 -= dx1;
255 }
258 }
259 next1:
260 while (1) {
261 e2 += dy2;
262 while (e2 >= dx2) {
263 e2 -= dx2;
266 }
269 }
270 next2:
277 t1x += t1xp;
279 t2x += t2xp;
280 y += 1;
281 if (y == y2) break;
282
283 }
284 next:
287 dy1 = (int)(y3 - y2);
288 t1x = x2;
289
290 if (dy1 > dx1) {
291 SWAP(dy1, dx1);
293 }
295
296 e1 = (int)(dx1 >> 1);
297
298 for (int i = 0; i <= dx1; i++) {
299 t1xp = 0; t2xp = 0;

302 while (i<dx1) {
303 e1 += dy1;
304 while (e1 >= dx1) {
305 e1 -= dx1;
308 }
311 if (i<dx1) i++;
312 }
313 next3:
314 while (t2x != x3) {
315 e2 += dy2;
316 while (e2 >= dx2) {
317 e2 -= dx2;
320 }
323 }
324 next4:
325
332 t1x += t1xp;
334 t2x += t2xp;
335 y += 1;
337 }
338 }
339
341 {
344
346 }
347
350 {
355 {
356 color=image[i];
359 }
360 out.close();
361 }
362
363 int main()
364 {
368 std::tuple<int,int,int,int,float,float,float,float> triangle;
376 int ctr=0;
379 {
380 if (startsWithCaseInsensitive(line,"t")) {
381 triangle=parse_triangle_line(line);
382 std::tie(x1,y1,x2,y2,rf,gf,bf,af) = triangle;
384 draw_filled_triangle(x1,y2,x2,y1,x1,y1,image,colorRGBA,width,height);
388 draw_filled_triangle(x1,y2,x2,y1,x2,y2,image,colorRGBA,width,height);
392 }
393
403 }
404 }
405 infile.close();
406
408
409 return 0;
410 }
15_radarchart.cpp - 13293 bytes.
1 // Compile: clang++ -std=c++17 15_radarchart.cpp -o 15_radarchart

3
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
11
13 {
15 }
16

18 {
20 }
21
23 height)
24 {
28 }
29 }
30 }
31
32 void draw_circle(int x, int y, int radius, std::vector<std::tuple<float, float, floa\
33 t>> &image, std::tuple<float, float, float> &color, int width, int height)
34 {
35 int x0 = 0;
36 int y0 = radius;
37 int d = 3 - 2 * radius;
38 int xx=0;
39 int yy=0;
42
43 while (y0 >= x0)
44 {
45 if (mask & 0x01) {xx=x + x0;yy=y - y0;image[get_index(xx, yy, width)]=color;}
46 if (mask & 0x02) {xx=x + y0;yy=y - x0;image[get_index(xx, yy, width)]=color;}
47 if (mask & 0x04) {xx=x + y0;yy=y + x0;image[get_index(xx, yy, width)]=color;}
48 if (mask & 0x08) {xx=x + x0;yy=y + y0;image[get_index(xx, yy, width)]=color;}
49 if (mask & 0x10) {xx=x - x0;yy=y + y0;image[get_index(xx, yy, width)]=color;}
50 if (mask & 0x20) {xx=x - y0;yy=y + x0;image[get_index(xx, yy, width)]=color;}
51 if (mask & 0x40) {xx=x - y0;yy=y - x0;image[get_index(xx, yy, width)]=color;}
52 if (mask & 0x80) {xx=x - x0;yy=y - y0;image[get_index(xx, yy, width)]=color;}
53 if (d < 0) d += 4 * x0++ + 6;
54 else d += 4 * (x0++ - y0--) + 10;
55 }
56 }
57
60 {
61 int x0 = 0;
62 int y0 = radius;
63 int d = 3 - 2 * radius;
65
67 {
68 for (int i = sx; i <= ex; i++)
70 };
71
72 while (y0 >= x0)
73 {
74 drawline(x - x0, x + x0, y - y0);
75 drawline(x - y0, x + y0, y - x0);
76 drawline(x - x0, x + x0, y + y0);
77 drawline(x - y0, x + y0, y + x0);
78 if (d < 0) d += 4 * x0++ + 6;
79 else d += 4 * (x0++ - y0--) + 10;
80 }
81 }
82
83 void floodfill_algorithm(int x, int y, std::vector<std::tuple<float, float, float>> \
84 &image, std::tuple<float, float, float> &ocolor, std::tuple<float, float, float> &nc
85 olor, int &width, int &height)
86 {
87 if ((x > 0) && (x < width) && (y > 0) && (y < height)) {
88 if (image[get_index(x,y,width)] == ocolor)
89 {
90 image[get_index(x,y,width)]=ncolor;
91 floodfill_algorithm(x+1,y,image,ocolor,ncolor,width,height);
92 floodfill_algorithm(x-1,y,image,ocolor,ncolor,width,height);
93 floodfill_algorithm(x,y+1,image,ocolor,ncolor,width,height);
94 floodfill_algorithm(x,y-1,image,ocolor,ncolor,width,height);
95 }
96 else return;
97 }
98 }
99
101 {
104 }
105
108 }
109
111 > &coords)
112 {
114 dx = x2 - x1; dy = y2 - y1;
115 if (dx == 0)
116 {
117 if (y2 < y1) std::swap(y1, y2);
118 for (y = y1; y <= y2; y++)
120 return;
121 }
122 if (dy == 0)
123 {
124 if (x2 < x1) std::swap(x1, x2);
125 for (x = x1; x <= x2; x++)
127 return;
128 }
130 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
131 if (dy1 <= dx1)
132 {
133 if (dx >= 0)
134 {
135 x = x1; y = y1; xe = x2;
136 }
137 else
138 {
139 x = x2; y = y2; xe = x1;
140 }
142 for (i = 0; x<xe; i++)
143 {
144 x = x + 1;
145 if (px<0)
146 px = px + 2 * dy1;
147 else
148 {
150 px = px + 2 * (dy1 - dx1);
151 }
153 }
154 }
155 else
156 {
157 if (dy >= 0)
158 {
159 x = x1; y = y1; ye = y2;
160 }
161 else
162 {
163 x = x2; y = y2; ye = y1;
164 }
166 for (i = 0; y<ye; i++)
167 {
168 y = y + 1;
169 if (py <= 0)
170 py = py + 2 * dx1;
171 else
172 {
174 py = py + 2 * (dx1 - dy1);
175 }
177 }
178 }
179 }
180
181 void draw_polygon(std::vector<std::tuple<int, int, int, int>> &polygon,std::vector<s\
182 td::tuple<float, float, float>> &image,std::tuple<float, float, float> &color, int w
184 {
186
187 for (auto& po : polygon) {
188 draw_line_coords(std::get<0>(po),std::get<1>(po),std::get<2>(po),std::get<3>(po),c\
189 oords);
190 }
191
194 }
195 }
196
197 void draw_filled_polygon(std::vector<std::tuple<int, int, int, int>> &polygon,std::v\
198 ector<std::tuple<float, float, float>> &image,std::tuple<float, float, float> &color
199 , int width, int height)
200 {
202
203 for (auto& po : polygon) {
204 draw_line_coords(std::get<0>(po),std::get<1>(po),std::get<2>(po),std::get<3>(po),c\
205 oords);
206 }
207
212
214 {
218 }
219 }
222 xs.clear();
223 }
224
226 {
227 for (int i = sx; i <= ex; i++)
229 };
230
233 }
234 }
235
238 {
242 dx = x2 - x1; dy = y2 - y1;
243 if (dx == 0)
244 {
245 if (y2 < y1) std::swap(y1, y2);
246 for (y = y1; y <= y2; y++)
248 return;
249 }
250 if (dy == 0)
251 {
252 if (x2 < x1) std::swap(x1, x2);
253 for (x = x1; x <= x2; x++)
255 return;
256 }
258 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
259 if (dy1 <= dx1)
260 {
261 if (dx >= 0)
262 {
263 x = x1; y = y1; xe = x2;
264 }
265 else
266 {
267 x = x2; y = y2; xe = x1;
268 }
270 for (i = 0; x<xe; i++)
271 {
272 x = x + 1;
273 if (px<0)
274 px = px + 2 * dy1;
275 else
276 {
278 px = px + 2 * (dy1 - dx1);
279 }
281 }
282 }
283 else
284 {
285 if (dy >= 0)
286 {
287 x = x1; y = y1; ye = y2;
288 }
289 else
290 {
291 x = x2; y = y2; ye = y1;
292 }
294 for (i = 0; y<ye; i++)
295 {
296 y = y + 1;
297 if (py <= 0)
298 py = py + 2 * dx1;
299 else
300 {
302 py = py + 2 * (dx1 - dy1);
303 }
305 }
306 }
307 }
308
310 {
311 int code=0;
312 if(y >= height)
313 code |= 1; //top
314 else if(y < 0)
316 if(x >= width)
318 else if (x < 0)

319 code |= 8; //left
320 return(code);
321 }
322
325 {
335 {
340 {
341 int x, y;
344 {
345 x = x1 + (x2 - x1) * (height - y1) / (y2 - y1);
346 y = height - 1;
347 }
349 {
350 x = x1 + (x2 - x1) * -y1 / (y2 - y1);
351 y = 0;
352 }
354 {
355 y = y1 + (y2 - y1) * (width - x1) / (x2 - x1);
356 x = width - 1;
357 }
358 else //left
359 {
360 y = y1 + (y2 - y1) * -x1 / (x2 - x1);
361 x = 0;
362 }
364 {
365 x1 = x; y1 = y;
367 }
369 {
370 x2 = x; y2 = y;
372 }
373 }
374 }
376 if(accept)
377 {
378 x3 = x1;
379 x4 = x2;
380 y3 = y1;
381 y4 = y2;
383 return 1;
384 }
385 else
386 {
387 x3 = x4 = y3 = y4 = 0;
389 return 0;
390 }
391 }
392
395 {
399 }
400
403 {

405 std::ofstream out(filename, std::ios_base::out | std::ios_base::binary);
406 out << "P6" << std::endl << width << ' ' << height << std::endl << "255" << std::en\
407 dl;
408
410 {
411 color=image[i];
412 out << char(std::get<0>(color)*255.0f) << char(std::get<1>(color)*255.0f) << char(\
413 std::get<2>(color)*255.0f);
414 }
415 out.close();
416 }
417
418 int main()
419 {
422
423
424 std::tuple<float,float,float> color=std::make_tuple(0.8470588235,0.8509803922,0.913\
425 7254902);
426 std::tuple<int, int, int, int> coord;
427 std::vector<std::tuple<int, int, int, int>> polygon;
428
429 int width=1920;
430 int height=1080;
431
434
435 int x_cen=width/2;
436 int y_cen=height/2;
437 int length=y_cen*0.8;
438 double degrees=0.0;
439
440 coord=std::make_tuple(1248,540,1113,693);
441 polygon.push_back(coord);
456
457 draw_filled_polygon(polygon,image,color,width,height);
458 color=std::make_tuple(1.0,0.0,1.0);
459 draw_polygon(polygon,image,color,width,height);
460
461 //
462
464 get_angle_line(coord,x_cen,y_cen,degrees,length);
465 if (clip_line(coord,coord,width,height)) {
466 draw_line(image,coord,color,width,height);
467 }
468 degrees=45.0;
472 }
473 degrees=90.0;
477 }
478 degrees=135.0;
482 }
483 degrees=180.0;
487 }
488 degrees=225.0;
492 }
493 degrees=270.0;
497 }
498 degrees=315.0;
502 }
503
504 // 432;72
505 draw_circle((width/2),(height/2),72,image,color,width,height);
506 draw_circle((width/2),(height/2),72*2,image,color,width,height);
511
513 draw_filled_circle(x_cen,y_cen,71,image,color,width,height);
514
515 //
516 std::tuple<float,float,float> ncolor=std::make_tuple(0.8470588235,0.8509803922,0.91\
517 37254902);
518 floodfill_algorithm(x_cen,y_cen,image,color,ncolor,width,height);
519
520 save_image(image,width,height,"15_radarchart.ppm");
521
522 return 0;
523 }
15_weekchart.cpp - 7689 bytes.

1 // Compile: clang++ -std=c++17 15_weekchart.cpp -o 15_weekchart
3
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
11
13 {
15 }
16
18 {
20 }
21
23 height)
24 {
27 image[get_index(x,y,width)]=std::make_tuple(0.1254901961, 0.1294117647, 0.14
28 706);
29 }
30 }
31 }
32
35 {
36 int x0 = 0;
37 int y0 = radius;
38 int d = 3 - 2 * radius;
40
42 {
43 for (int i = sx; i <= ex; i++)

45 };
46
47 while (y0 >= x0)
48 {
49 drawline(x - x0, x + x0, y - y0);
50 drawline(x - y0, x + y0, y - x0);
51 drawline(x - x0, x + x0, y + y0);
52 drawline(x - y0, x + y0, y + x0);
53 if (d < 0) d += 4 * x0++ + 6;
54 else d += 4 * (x0++ - y0--) + 10;
55 }
56 }
57
59 {
62 }
63
66 }
67
69 > &coords)
70 {
72 dx = x2 - x1; dy = y2 - y1;
73 if (dx == 0)
74 {
75 if (y2 < y1) std::swap(y1, y2);
76 for (y = y1; y <= y2; y++)
78 return;
79 }
80 if (dy == 0)
81 {
82 if (x2 < x1) std::swap(x1, x2);
83 for (x = x1; x <= x2; x++)
85 return;
86 }
88 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
89 if (dy1 <= dx1)
90 {
91 if (dx >= 0)
92 {
93 x = x1; y = y1; xe = x2;
94 }
95 else
96 {
97 x = x2; y = y2; xe = x1;
98 }
100 for (i = 0; x<xe; i++)
101 {
102 x = x + 1;
103 if (px<0)
104 px = px + 2 * dy1;
105 else
106 {
108 px = px + 2 * (dy1 - dx1);
109 }
111 }
112 }
113 else
114 {
115 if (dy >= 0)
116 {
117 x = x1; y = y1; ye = y2;
118 }
119 else
120 {
121 x = x2; y = y2; ye = y1;
122 }
124 for (i = 0; y<ye; i++)
125 {
126 y = y + 1;
127 if (py <= 0)
128 py = py + 2 * dx1;
129 else
130 {
132 py = py + 2 * (dx1 - dy1);
133 }
135 }
136 }
137 }
138
139 void draw_wedge(int x_cen,int y_cen,int rad,int start_ang,int end_ang,std::vector<st\
140 d::tuple<float, float, float>> &image,std::tuple<float, float, float> &color, int wi
141 dth, int height)
142 {
144
149 do
150 {
152 ang+=0.001;
155 }
157
160
163
166 }
167 }
168
172 {
174
179 do
180 {
182 ang+=0.001;
185 }
187
190
193
198
200 {
204 }
205 }
208 xs.clear();
209 }
210
212 {
213 for (int i = sx; i <= ex; i++)
215 };
216
219 }
220 }
221
224 {
228 dl;
229
231 {
232 color=image[i];
234 std::get<2>(color)*255.0f);
235 }
236 out.close();
237 }
238
239 int main()
240 {
241 int width=1920;
242 int height=1080;
243
244 float a1[] = {0.89,1.00,0.86,0.84,0.80,0.87,0.86,0.92,0.82,0.91,0.85,0.80,1.00,0.87\
245 ,0.85,0.93,0.97,0.94,1.00,0.91,0.85,0.92,0.96,0.82,0.94,0.83,0.93,0.95,1.00,0.98,0.9
246 6,0.97,0.80,1.00,0.93,0.86,0.90,0.93,0.92,0.90,0.92,0.98,0.84,1.00,0.92,0.92,0.83,0.
247 89,0.90,0.99,0.97,0.92};
248 float a2[] = {0.70,0.51,0.69,0.52,0.56,0.59,0.50,0.68,0.73,0.46,0.40,0.56,0.41,0.54\
249 ,0.64,0.45,0.56,0.45,0.41,0.60,0.68,0.45,0.65,0.60,0.65,0.66,0.57,0.47,0.47,0.58,0.5
250 7,0.48,0.41,0.62,0.50,0.46,0.75,0.50,0.71,0.56,0.57,0.53,0.75,0.45,0.51,0.47,0.71,0.
251 74,0.51,0.72,0.56,0.71};
252 float a3[] = {0.21,0.11,0.13,0.21,0.04,0.21,0.24,0.26,0.32,0.28,0.09,0.15,0.19,0.28\
253 ,0.22,0.25,0.03,0.22,0.18,0.15,0.31,0.08,0.27,0.07,0.08,0.10,0.08,0.23,0.17,0.11,0.3
254 4,0.29,0.10,0.09,0.06,0.31,0.32,0.22,0.26,0.21,0.14,0.13,0.08,0.15,0.27,0.04,0.06,0.
255 17,0.10,0.02,0.12,0.17};
256
258 std::tuple<float,float,float> bg=std::make_tuple(0.3058823529,0.2509803922,0.227450\

259 9804);
260 std::tuple<float,float,float> color1=std::make_tuple(0.5254901961,0.4588235294,0.39\
261 60784314);
262 std::tuple<float,float,float> color2=std::make_tuple(0.6352941176,0.6196078431,0.6);
263 std::tuple<float,float,float> color3=std::make_tuple(0.8117647059,0.7607843137,0.70\
264 58823529);
265
268
269 int x_cen,y_cen,rad;
270 double start_ang,end_ang,length,rad_size,color_size,color_num=0.0;
271 x_cen=width/2;
272 y_cen=height/2;
273 rad=y_cen*0.8;
274 start_ang=0;
275 end_ang=6.9230769231;
276 image[get_index(x_cen,y_cen, width)]=color1;
277 rad_size=rad/52;
278 length=rad;
279 color_size=1.0/52;
280
281 draw_filled_circle(x_cen,y_cen,y_cen*0.9,image,bg,width,height);
282
283 for (int i=0;i<52;++i) {
284 draw_filled_wedge(x_cen,y_cen,length*a1[i],start_ang,end_ang,image,color1,width,he\
285 ight);
287 ight);
289 ight);
290 start_ang=end_ang;end_ang+=6.9230769231;
291 }
292
293 save_image(image,width,height,"15_weekchart.ppm");
294
295 return 0;
296 }
15_read_p6_ppm.cpp - 2283 bytes.

1 // Pre: cp 15_weekchart.ppm 15_read_p6_ppm.ppm
2 // Compile: clang++ -std=c++17 15_read_p6_ppm.cpp -o 15_read_p6_ppm
3
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
10
11 void load_image(std::vector<std::tuple<float, float, float>> &image, int &width, int\
13 {
14 std::string magic;
15 int max;
16 uint8_t buffer[3];
18
19 std::ifstream in(filename, std::ifstream::binary);
20
21 if (!in.is_open())
22 {
23 std::cout << "Can't open " << filename << std::endl;
24 exit(1);
25 }
26
27 in >> magic;
28 in.seekg(1, in.cur);
29 char c;
30 in.get(c);
31 if (c == '#')
32 {
33 // We got comments in the PPM image and skip the comments
34 while (c != '\n')
35 {
36 in.get(c);
37 }
38 }
39 else
40 {
41 in.seekg(-1, in.cur);
42 }
43
44 in >> width >> height >> max;
45
46 if (max != 255) {
47 std::cout << "Not 8 bit per rgb color." << std::endl;
48 exit(1);
49 }
50
51 if (magic == "P6")
52 {
53 // Move curser once to skip '\n'
55
56 for (int i = 0; i < width * height; ++i)
57 {
58 in.read(reinterpret_cast<char *>(buffer), 3);
59 color=std::make_tuple(float(float(buffer[0])/255.0),float(float(buffer[1])/2
60 ,float(float(buffer[2])/255.0));
61 image.push_back(color);
62 }
63 } else {
64 std::cout << "Not a P6 file." << std::endl;
65 exit(1);
66 }
67
68 in.close();
69 }
70
73 {
77 dl;
78
80 {
81 color=image[i];
83 std::get<2>(color)*255.0f);
84 }
85 out.close();
86 }
87
88 int main()
89 {
91 int width,height;
92
93 std::cout << "loading: 15_read_p6_ppm.ppm" << std::endl;
94 load_image(image,width,height,"15_read_p6_ppm.ppm");
95 std::cout << "15_read_p6_ppm.ppm - w: " << width << " " << "h: " << height << std::\
96 endl;
97
98 std::cout << "saving: 15_read_p6_ppm_.ppm." << std::endl;
99 save_image(image,width,height,"15_read_p6_ppm_.ppm");
100
101 return 0;
102 }
15_draw_font.cpp - 37008 bytes.
1 // Compile: clang++ -std=c++17 15_draw_font.cpp -o 15_draw_font

2
5 #include <tuple>
6 #include <vector>
7 #include <random>
8 #include <cmath>
9
10 void get_width_from_height(int &width, int height)
11 {
12 int half = height / 2;
13 width = half * 3;
14 }
15
16 void get_margin_from_height(int &margin,int height)
17 {
18 margin = int(float(height) * 0.3);
19 }
20
22 {
24 }
25
26 int calc_size(int width, int height, int margin)
27 {
28 return (width+margin)*(height+margin);
29 }
30
32 height, int margin)
33 {
34 for (int y=0;y<(height+margin);++y) {
35 for (int x=0;x<(width+margin);++x) {
36 image[get_index(x,y,(width+margin))]=std::make_tuple(1.0f, 1.0f, 1.0f);
37 }
38 }
39 }
40
42 t, float>> &image, std::tuple<float, float, float> &color, int width, int height, in
43 t margin)
44 {
45 int x0 = 0;
46 int y0 = radius;
47 int d = 3 - 2 * radius;
49
51 {
52 for (int i = sx; i <= ex; i++)
53 image[get_index(i, ny, width+margin)]=color;
54 };
55
56 while (y0 >= x0)
57 {
58 drawline(x - x0, x + x0, y - y0);
59 drawline(x - y0, x + y0, y - x0);
60 drawline(x - x0, x + x0, y + y0);
61 drawline(x - y0, x + y0, y + x0);
62 if (d < 0) d += 4 * x0++ + 6;
63 else d += 4 * (x0++ - y0--) + 10;
64 }
65 }
66
67 void get_line_points(std::vector<std::tuple<int,int>> &points, std::tuple<int, int, \

68 int, int> &coords, std::tuple<float,float,float> &color, int width, int height, int
69 margin)
70 {
74 dx = x2 - x1; dy = y2 - y1;
75 if (dx == 0)
76 {
77 if (y2 < y1) std::swap(y1, y2);
78 for (y = y1; y <= y2; y++)
79 points.push_back(std::make_tuple(x1,y));
80 return;
81 }
82 if (dy == 0)
83 {
84 if (x2 < x1) std::swap(x1, x2);
85 for (x = x1; x <= x2; x++)
86 points.push_back(std::make_tuple(x,y1));
87 return;
88 }
90 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
91 if (dy1 <= dx1)
92 {
93 if (dx >= 0)
94 {
95 x = x1; y = y1; xe = x2;
96 }
97 else
98 {
99 x = x2; y = y2; xe = x1;
100 }
101 points.push_back(std::make_tuple(x,y));
102 for (i = 0; x<xe; i++)
103 {
104 x = x + 1;
105 if (px<0)
106 px = px + 2 * dy1;
107 else
108 {
110 px = px + 2 * (dy1 - dx1);

111 }
113 }
114 }
115 else
116 {
117 if (dy >= 0)
118 {
119 x = x1; y = y1; ye = y2;
120 }
121 else
122 {
123 x = x2; y = y2; ye = y1;
124 }
126 for (i = 0; y<ye; i++)
127 {
128 y = y + 1;
129 if (py <= 0)
130 py = py + 2 * dx1;
131 else
132 {
134 py = py + 2 * (dx1 - dy1);
135 }
137 }
138 }
139 }
140
141 void draw_font_A(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
142 oat> &color, int width, int height, int margin)
143 {
144 // A
145 //points
146 float arr[4][2] = {{0.0,1.0},{0.5,0.0},{1.0,1.0},{0.0,0.6}};
147 //lines
148 int arr2[3][2] = {{0,1},{1,2},{2,3}};
150 int halfmargin=margin/2;
151
152 for (int i=0;i<3;++i) {
153 coords=std::make_tuple(int(width*arr[arr2[i][0]][0])+halfmargin, int(height*arr[ar\

154 r2[i][0]][1])+halfmargin, int(width*arr[arr2[i][1]][0])+halfmargin, int(height*arr[a
155 rr2[i][1]][1])+halfmargin);
156 get_line_points(points,coords,color,width,height,margin);
157 }
158 }
159
160 void draw_font_B(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
162 {
163 // B
164 //points
165 float arr[7][2] = {{0.0,0.0},{1.0,0.0},{1.0,0.4},{0.5,0.5},{1.0,0.6},{1.0,1.0},{0.0\
166 ,1.0}};
167 //lines
168 int arr2[7][2] = {{0,1},{1,2},{2,3},{3,4},{4,5},{5,6},{6,0}};
171
172 for (int i=0;i<7;++i) {
174 r2[i][0]][1])+halfmargin, int(width*arr[arr2[i][1]][0]+halfmargin), int(height*arr[a
177 }
178 }
179
180 void draw_font_C(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
182 {
183 // C
184 //points
185 float arr[4][2] = {{0.5,0.0},{0.0,0.0},{0.0,1.0},{1.0,1.0}};
186 //lines
187 int arr2[3][2] = {{0,1},{1,2},{2,3}};
190
191 for (int i=0;i<3;++i) {
196 }
197 }
198
199 void draw_font_D(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
201 {
202 // D
203 //points
204 float arr[4][2] = {{0.0,0.0},{0.0,1.0},{1.0,1.0},{1.0,0.4}};
205 //lines
206 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,0}};
209
210 for (int i=0;i<4;++i) {
215 }
216 }
217
218 void draw_font_E(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
220 {
221 // E
222 //points
223 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.5},{0.5,0.5},{0.0,1.0},{1.0,1.0}};
224 //lines
225 int arr2[4][2] = {{0,1},{1,2},{2,3},{4,5}};
228
229 for (int i=0;i<4;++i) {
234 }
235 }
236
237 void draw_font_F(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
239 {
240 // F
241 //points
242 float arr[5][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.4},{0.5,0.4},{0.0,1.0}};
243 //lines
244 int arr2[4][2] = {{0,1},{1,2},{2,3},{2,4}};
247
248 for (int i=0;i<4;++i) {
253 }
254 }
255
256 void draw_font_G(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
258 {
259 // G
260 //points
261 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,1.0},{1.0,1.0},{1.0,0.6},{0.5,0.6}};
262 //lines
263 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
266
267 for (int i=0;i<5;++i) {
272 }
273 }
274
275 void draw_font_H(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
277 {
278 // H
279 //points
280 float arr[6][2] = {{0.0,0.0},{0.0,1.0},{1.0,0.0},{1.0,1.0},{0.0,0.6},{1.0,0.6}};
281 //lines
282 int arr2[3][2] = {{0,1},{2,3},{4,5}};

285
286 for (int i=0;i<3;++i) {
291 }
292 }
293
294 void draw_font_I(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
296 {
297 // I
298 //points
299 float arr[2][2] = {{0.5,0.0},{0.5,1.0}};
300 //lines
301 int arr2[1][2] = {{0,1}};
304
305 for (int i=0;i<1;++i) {
310 }
311 }
312
313 void draw_font_J(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
315 {
316 // J
317 //points
318 float arr[4][2] = {{0.5,0.0},{0.5,1.0},{0.25,1.0},{0.0,0.6}};
319 //lines
320 int arr2[3][2] = {{0,1},{1,2},{2,3}};
323
324 for (int i=0;i<3;++i) {

329 }
330 }
331
332 void draw_font_K(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
334 {
335 // K
336 //points
337 float arr[5][2] = {{0.0,0.0},{0.0,0.4},{0.5,0.0},{1.0,1.0},{0.0,1.0}};
338 //lines
339 int arr2[4][2] = {{0,1},{1,2},{1,3},{1,4}};
342
343 for (int i=0;i<4;++i) {
348 }
349 }
350
351 void draw_font_L(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
353 {
354 // L
355 //points
356 float arr[3][2] = {{0.0,0.0},{0.0,1.0},{1.0,1.0}};
357 //lines
358 int arr2[2][2] = {{0,1},{1,2}};
361
362 for (int i=0;i<2;++i) {
367 }
368 }
369
370 void draw_font_M(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
372 {
373 // M
374 //points
375 float arr[5][2] = {{0.0,1.0},{0.0,0.0},{0.5,0.3},{1.0,0.0},{1.0,1.0}};
376 //lines
377 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,4}};
380
381 for (int i=0;i<4;++i) {
386 }
387 }
388
389 void draw_font_N(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
391 {
392 // N
393 //points
394 float arr[6][2] = {{0.0,0.0},{0.0,1.0},{1.0,0.0},{1.0,1.0},{0.0,0.0},{1.0,1.0}};
395 //lines
396 int arr2[3][2] = {{0,1},{2,3},{4,5}};
399
400 for (int i=0;i<3;++i) {
405 }
406 }
407
408 void draw_font_O(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
410 {
411 // O
412 //points
413 float arr[4][2] = {{1.0,0.0},{1.0,1.0},{0.0,1.0},{0.0,0.0}};
414 //lines
415 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,0}};
418
419 for (int i=0;i<4;++i) {
424 }
425 }
426
427 void draw_font_P(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
429 {
430 // P
431 //points
432 float arr[5][2] = {{0.0,1.0},{0.0,0.0},{1.0,0.0},{1.0,0.3},{0.0,0.6}};
433 //lines
434 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,4}};
437
438 for (int i=0;i<4;++i) {
443 }
444 }
445
446 void draw_font_Q(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
448 {
449 // Q
450 //points
451 float arr[7][2] = {{1.0,0.6},{1.0,0.0},{0.0,0.0},{0.0,1.0},{0.5,1.0},{0.5,0.6},{1.0\
452 ,1.0}};
453 //lines
454 int arr2[6][2] = {{0,1},{1,2},{2,3},{3,4},{4,0},{5,6}};

457
458 for (int i=0;i<6;++i) {
463 }
464 }
465
466 void draw_font_R(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
468 {
469 // R
470 //points
471 float arr[6][2] = {{0.0,1.0},{0.0,0.0},{1.0,0.0},{1.0,0.3},{0.0,0.6},{1.0,1.0}};
472 //lines
473 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
476
477 for (int i=0;i<5;++i) {
482 }
483 }
484
485 void draw_font_S(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
487 {
488 // S
489 //points
490 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.4},{1.0,0.6},{1.0,1.0},{0.0,1.0}};
491 //lines
492 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
495
496 for (int i=0;i<5;++i) {

501 }
502 }
503
504 void draw_font_T(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
506 {
507 // T
508 //points
509 float arr[3][2] = {{0.0,0.0},{1.0,0.0},{1.0,1.0}};
510 //lines
511 int arr2[2][2] = {{0,1},{1,2}};
514
515 for (int i=0;i<2;++i) {
520 }
521 }
522
523 void draw_font_U(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
525 {
526 // U
527 //points
528 float arr[4][2] = {{0.0,0.0},{0.0,1.0},{1.0,1.0},{1.0,0.5}};
529 //lines
530 int arr2[3][2] = {{0,1},{1,2},{2,3}};
533
534 for (int i=0;i<3;++i) {
539 }
540 }
541
542 void draw_font_V(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
544 {
545 // V
546 //points
547 float arr[3][2] = {{0.0,0.0},{0.5,1.0},{1.0,0.0}};
548 //lines
549 int arr2[2][2] = {{0,1},{1,2}};
552
553 for (int i=0;i<2;++i) {
558 }
559 }
560
561 void draw_font_W(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
563 {
564 // W
565 //points
566 float arr[5][2] = {{0.0,0.0},{0.0,1.0},{0.5,0.7},{1.0,1.0},{1.0,0.0}};
567 //lines
568 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,4}};
571
572 for (int i=0;i<4;++i) {
577 }
578 }
579
580 void draw_font_X(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
582 {
583 // X
584 //points
585 float arr[5][2] = {{0.5,0.6},{0.0,0.0},{1.0,0.0},{1.0,1.0},{0.0,1.0}};
586 //lines
587 int arr2[4][2] = {{0,1},{0,2},{0,3},{0,4}};
590
591 for (int i=0;i<4;++i) {
596 }
597 }
598
599 void draw_font_Y(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
601 {
602 // Y
603 //points
604 float arr[4][2] = {{0.5,0.6},{0.0,0.0},{1.0,0.0},{0.5,1.0}};
605 //lines
606 int arr2[3][2] = {{0,1},{0,2},{0,3}};
609
610 for (int i=0;i<3;++i) {
615 }
616 }
617
618 void draw_font_Z(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
620 {
621 // Z
622 //points
623 float arr[4][2] = {{0.0,0.0},{1.0,0.0},{0.0,1.0},{1.0,1.0}};
624 //lines
625 int arr2[3][2] = {{0,1},{1,2},{2,3}};

628
629 for (int i=0;i<3;++i) {
634 }
635 }
636
637 void draw_font_0(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,fl\
639 {
640 // 0
641 //points
642 float arr[6][2] = {{0.0,0.0},{0.0,1.0},{1.0,1.0},{1.0,0.0},{0.0,1.0},{1.0,0.0}};
643 //lines
644 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,0},{4,5}};
647
648 for (int i=0;i<5;++i) {
653 }
654 }
655
658 {
659 // 1
660 //points
661 float arr[3][2] = {{0.0,0.0},{0.5,0.0},{0.5,1.0}};
662 //lines
663 int arr2[2][2] = {{0,1},{1,2}};
666
667 for (int i=0;i<2;++i) {

672 }
673 }
674
677 {
678 // 2
679 //points
680 float arr[6][2] = {{0.0,0.0},{1.0,0.0},{1.0,0.4},{0.0,0.6},{0.0,1.0},{1.0,1.0}};
681 //lines
682 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
685
686 for (int i=0;i<5;++i) {
691 }
692 }
693
696 {
697 // 3
698 //points
699 float arr[6][2] = {{0.0,0.0},{1.0,0.0},{1.0,0.4},{0.5,0.4},{0.0,1.0},{1.0,1.0}};
700 //lines
701 int arr2[4][2] = {{0,1},{1,2},{2,3},{4,5}};
704
705 for (int i=0;i<4;++i) {
710 }
711 }
712
715 {
716 // 4
717 //points
718 float arr[5][2] = {{0.0,0.0},{0.0,0.4},{1.0,0.6},{1.0,0.0},{1.0,1.0}};
719 //lines
720 int arr2[3][2] = {{0,1},{1,2},{3,4}};
723
724 for (int i=0;i<3;++i) {
729 }
730 }
731
734 {
735 // 5
736 //points
737 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.5},{1.0,0.6},{1.0,1.0},{0.0,1.0}};
738 //lines
739 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
742
743 for (int i=0;i<5;++i) {
748 }
749 }
750
753 {
754 // 6
755 //points
756 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.4},{1.0,0.6},{1.0,1.0},{0.0,1.0}};
757 //lines
758 int arr2[5][2] = {{0,1},{1,5},{5,4},{3,4},{3,2}};
761
762 for (int i=0;i<5;++i) {
767 }
768 }
769
772 {
773 // 7
774 //points
775 float arr[3][2] = {{0.0,0.0},{1.0,0.0},{1.0,1.0}};
776 //lines
777 int arr2[2][2] = {{0,1},{1,2}};
780
781 for (int i=0;i<2;++i) {
786 }
787 }
788
791 {
792 // 8
793 //points
794 float arr[6][2] = {{0.1,0.4},{0.9,0.6},{1.0,0.0},{0.0,0.0},{0.0,1.0},{1.0,1.0}};
795 //lines
796 int arr2[7][2] = {{0,1},{1,2},{2,3},{3,0},{0,4},{4,5},{5,1}};

799
800 for (int i=0;i<7;++i) {
805 }
806 }
807
810 {
811 // 9
812 //points
813 float arr[5][2] = {{1.0,1.0},{1.0,0.0},{0.0,0.0},{0.0,0.6},{1.0,0.4}};
814 //lines
815 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,4}};
818
819 for (int i=0;i<4;++i) {
824 }
825 }
826
827 void draw_font_QA(std::vector<std::tuple<int,int>> &points, std::tuple<float,float,f\
828 loat> &color, int width, int height, int margin)
829 {
830 // ?
831 //points
832 float arr[6][2] = {{0.0,0.0},{1.0,0.0},{1.0,0.4},{0.5,0.4},{0.5,0.8},{0.5,1.0}};
833 //lines
834 int arr2[4][2] = {{0,1},{1,2},{2,3},{4,5}};
837
838 for (int i=0;i<4;++i) {
843 }
844 }
845
846 void draw_font_PROCENT(std::vector<std::tuple<int,int>> &points, std::tuple<float,fl\
847 oat,float> &color, int width, int height, int margin)
848 {
849 // %
850 //points
851 float arr[10][2] = {{0.0,0.0},{0.3,0.0},{0.3,0.3},{0.0,0.3},{1.0,1.0},{0.7,1.0},{0.\
852 7,0.7},{1.0,0.7},{0.0,1.0},{1.0,0.0}};
853 //lines
854 int arr2[9][2] = {{0,1},{1,2},{2,3},{3,0},{4,5},{5,6},{6,7},{7,4},{8,9}};
857
858 for (int i=0;i<9;++i) {
863 }
864 }
865
867 height, int margin, std::string filename)
868 {
871 out << "P6" << std::endl << (width+margin) << ' ' << (height+margin) << std::endl <\
872 < "255" << std::endl;
873
874 for (int i=0;i<((width+margin)*(height+margin));++i)
875 {
876 color=image[i];
878 std::get<2>(color)*255.0f);
879 }
880 out.close();
881 }
882
883 void draw(std::vector<std::tuple<int,int>> points,std::vector<std::tuple<float, floa\
884 t, float>> &image, std::tuple<float,float,float> color, int width, int height, int m
885 argin, int linesize)
886 {
887 for (auto& p : points) {
888 if (linesize == 1) {
889 image[get_index(std::get<0>(p),std::get<1>(p),width+margin)]=std::make_tuple
890 , 0.0f, 0.0f);
891 } else {
892 draw_filled_circle(std::get<0>(p),std::get<1>(p),linesize,image,color,width,
893 t,margin);
894 }
895 }
896 }
897
898 void draw_and_save_font(std::vector<std::tuple<float, float, float>> &image, std::tu\
899 ple<float,float,float> color, int width, int height, int margin, int linesize)
900 {
901 std::vector<std::tuple<int,int>> points;
902 draw_font_A(points,color,width,height,margin);
903 draw(points,image,color,width,height,margin,linesize);
904 save_image(image,width,height,margin,"15_draw_font_A.ppm");
905 points.clear();clear_image(image,width,height,margin);
906 draw_font_B(points,color,width,height,margin);
908 save_image(image,width,height,margin,"15_draw_font_B.ppm");
910 draw_font_C(points,color,width,height,margin);
912 save_image(image,width,height,margin,"15_draw_font_C.ppm");
914 draw_font_D(points,color,width,height,margin);
916 save_image(image,width,height,margin,"15_draw_font_D.ppm");
918 draw_font_E(points,color,width,height,margin);
920 save_image(image,width,height,margin,"15_draw_font_E.ppm");
922 draw_font_F(points,color,width,height,margin);
924 save_image(image,width,height,margin,"15_draw_font_F.ppm");
926 draw_font_G(points,color,width,height,margin);
928 save_image(image,width,height,margin,"15_draw_font_G.ppm");
930 draw_font_H(points,color,width,height,margin);
932 save_image(image,width,height,margin,"15_draw_font_H.ppm");
934 draw_font_I(points,color,width,height,margin);
936 save_image(image,width,height,margin,"15_draw_font_I.ppm");
938 draw_font_J(points,color,width,height,margin);
940 save_image(image,width,height,margin,"15_draw_font_J.ppm");
942 draw_font_K(points,color,width,height,margin);
944 save_image(image,width,height,margin,"15_draw_font_K.ppm");
946 draw_font_L(points,color,width,height,margin);
948 save_image(image,width,height,margin,"15_draw_font_L.ppm");
950 draw_font_M(points,color,width,height,margin);
952 save_image(image,width,height,margin,"15_draw_font_M.ppm");
954 draw_font_N(points,color,width,height,margin);
956 save_image(image,width,height,margin,"15_draw_font_N.ppm");
958 draw_font_O(points,color,width,height,margin);
960 save_image(image,width,height,margin,"15_draw_font_O.ppm");
962 draw_font_P(points,color,width,height,margin);
964 save_image(image,width,height,margin,"15_draw_font_P.ppm");
966 draw_font_Q(points,color,width,height,margin);
968 save_image(image,width,height,margin,"15_draw_font_Q.ppm");
970 draw_font_R(points,color,width,height,margin);
972 save_image(image,width,height,margin,"15_draw_font_R.ppm");
974 draw_font_S(points,color,width,height,margin);
976 save_image(image,width,height,margin,"15_draw_font_S.ppm");
978 draw_font_T(points,color,width,height,margin);
980 save_image(image,width,height,margin,"15_draw_font_T.ppm");
982 draw_font_U(points,color,width,height,margin);
984 save_image(image,width,height,margin,"15_draw_font_U.ppm");
986 draw_font_V(points,color,width,height,margin);
988 save_image(image,width,height,margin,"15_draw_font_V.ppm");
990 draw_font_W(points,color,width,height,margin);
992 save_image(image,width,height,margin,"15_draw_font_W.ppm");
994 draw_font_X(points,color,width,height,margin);
996 save_image(image,width,height,margin,"15_draw_font_X.ppm");
998 draw_font_Y(points,color,width,height,margin);
1000 save_image(image,width,height,margin,"15_draw_font_Y.ppm");
1002 draw_font_Z(points,color,width,height,margin);
1004 save_image(image,width,height,margin,"15_draw_font_Z.ppm");
1006 draw_font_0(points,color,width,height,margin);
1008 save_image(image,width,height,margin,"15_draw_font_0.ppm");
1046 draw_font_QA(points,color,width,height,margin);
1048 save_image(image,width,height,margin,"15_draw_font_questionmark.ppm");
1050 draw_font_PROCENT(points,color,width,height,margin);
1052 save_image(image,width,height,margin,"15_draw_font_procent.ppm");
1053 }
1054
1055 int main()
1056 {
1057 int width=0;int height=40;
1058 int margin=0;
1059 int linesize=3;
1062
1063 get_width_from_height(width,height);
1064 get_margin_from_height(margin,height);
1065 std::cout << "w: " << width << " h: " << height << " m: " << margin << " ls: " << l\
1066 inesize << std::endl;
1067
1068 image.resize(calc_size(width, height, margin));
1069 clear_image(image,width,height,margin);
1070
1071 draw_and_save_font(image,color,width,height,margin,linesize);
1072
1073 return 0;
1074 }
16_draw_bar_chart.cpp - 15032 bytes.
1 // Compile: clang++ -std=c++17 16_draw_bar_chart.cpp -o 16_draw_bar_chart

2
5 #include <tuple>
6 #include <vector>
7 #include <random>
8 #include <cmath>
9
11 {
13 }
14
16 {
18 }
19
22 {
25 image[get_index(x,y,(width+margin))]=std::make_tuple(0.262745098f, 0.2627450
26 0.262745098f);
27 }
28 }
29 }
30
33 {
34 int x2 = x + w;
35 int y2 = y + h;
36
37 if (x < 0) {x = 0;}
39 if (y < 0) {y = 0;}
41
42 if (x2 < 0) {x2 = 0;}
44 if (y2 < 0) {y2 = 0;}
46
47 for (int i = y; i < y2; i++) {
48 for (int j = x; j < x2; j++) {
50 }
51 }
52 }
53
56 {
60 dx = x2 - x1; dy = y2 - y1;
61 if (dx == 0)
62 {
63 if (y2 < y1) std::swap(y1, y2);
64 for (y = y1; y <= y2; y++)
66 return;
67 }
68 if (dy == 0)
69 {
70 if (x2 < x1) std::swap(x1, x2);
71 for (x = x1; x <= x2; x++)
73 return;
74 }
76 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
77 if (dy1 <= dx1)
78 {
79 if (dx >= 0)
80 {
81 x = x1; y = y1; xe = x2;
82 }
83 else
84 {
85 x = x2; y = y2; xe = x1;
86 }
88 for (i = 0; x<xe; i++)
89 {
90 x = x + 1;
91 if (px<0)
92 px = px + 2 * dy1;
93 else
94 {
96 px = px + 2 * (dy1 - dx1);
97 }
99 }
100 }
101 else
102 {
103 if (dy >= 0)
104 {
105 x = x1; y = y1; ye = y2;
106 }
107 else
108 {
109 x = x2; y = y2; ye = y1;
110 }
112 for (i = 0; y<ye; i++)
113 {
114 y = y + 1;
115 if (py <= 0)
116 py = py + 2 * dx1;
117 else
118 {
120 py = py + 2 * (dx1 - dy1);
121 }
123 }
124 }
125 }
126
129 {
133 dl;
134
136 {
137 color=image[i];
139 std::get<2>(color)*255.0f);
140 }
141 out.close();
142 }
143
144 int main()
145 {
148 std::tuple<float,float,float> color=std::make_tuple(1.0f,0.7647058824f,0.6235294118\
149 f);
150 int width=1600,height=900;
151 int margin=0;

152 int linesize=3;
153
156
157 draw_filled_rect(560,268,74,420,image,color,width,height);
162
163 // icon 1
184
185 // icon 2
186 draw_filled_rect(577+(1*136),714,3,39,image,color,width,height);
206
207 // icon 3
228
229 // icon 4
250
251 // 35%
290
291 // 23%
326
327 // 10%
356
357 // 32%
394
395 std::cout << "saving: 16_draw_bar_chart.ppm." << std::endl;
396 save_image(image,width,height,"16_draw_bar_chart.ppm");
397
398 return 0;
399 }
16_draw_pie_chart.cpp - 21225 bytes.

1 // Compile: clang++ -std=c++17 16_draw_pie_chart.cpp -o 16_draw_pie_chart
3
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
11
13 {
16 }
17
19 {
21 }
22
24 {
26 }
27
29 {
31 }
32
33 void stamp(std::vector<std::tuple<float, float, float>> &image, std::vector<std::tup\
34 le<float, float, float>> &letter, int offsetx, int offsety, int inputwidth, int inpu
35 theight, int width)
36 {
37 int inputx=0;
38 int inputy=0;
39 for (int y = offsety; y < offsety+inputheight; ++y)
40 {
41 for (int x = offsetx; x < offsetx+inputwidth; ++x)
42 {
43 image[get_index(x,y,width)]=letter[get_index(inputx,inputy,inputwidth)];
44 inputx++;
45 }
46 inputy++;
47 inputx=0;
48 }
49 }
50
53 {
56 image[get_index(x,y,(width+margin))]=std::make_tuple(1.0f,0.7647058824f,0.62
57 118f);
58 }
59 }
60 }
61
63 int, int> &coords, std::tuple<float,float,float> &color, int width, int height, int
64 margin)
65 {
69 dx = x2 - x1; dy = y2 - y1;
70 if (dx == 0)
71 {
72 if (y2 < y1) std::swap(y1, y2);
73 for (y = y1; y <= y2; y++)
75 return;
76 }
77 if (dy == 0)
78 {
79 if (x2 < x1) std::swap(x1, x2);
80 for (x = x1; x <= x2; x++)
82 return;
83 }
85 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
86 if (dy1 <= dx1)

87 {
88 if (dx >= 0)
89 {
90 x = x1; y = y1; xe = x2;
91 }
92 else
93 {
94 x = x2; y = y2; xe = x1;
95 }
97 for (i = 0; x<xe; i++)
98 {
99 x = x + 1;
100 if (px<0)
101 px = px + 2 * dy1;
102 else
103 {
105 px = px + 2 * (dy1 - dx1);
106 }
108 }
109 }
110 else
111 {
112 if (dy >= 0)
113 {
114 x = x1; y = y1; ye = y2;
115 }
116 else
117 {
118 x = x2; y = y2; ye = y1;
119 }
121 for (i = 0; y<ye; i++)
122 {
123 y = y + 1;
124 if (py <= 0)
125 py = py + 2 * dx1;
126 else
127 {
129 py = py + 2 * (dx1 - dy1);

130 }
132 }
133 }
134 }
135
138 {
139 // M
140 //points
141 float arr[5][2] = {{0.0,1.0},{0.0,0.0},{0.5,0.3},{1.0,0.0},{1.0,1.0}};
142 //lines
143 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,4}};
146
147 for (int i=0;i<4;++i) {
152 }
153 }
154
157 {
158 // A
159 //points
160 float arr[4][2] = {{0.0,1.0},{0.5,0.0},{1.0,1.0},{0.0,0.6}};
161 //lines
162 int arr2[3][2] = {{0,1},{1,2},{2,3}};
165
166 for (int i=0;i<3;++i) {
171 }
172 }
173
176 {
177 // R
178 //points
179 float arr[6][2] = {{0.0,1.0},{0.0,0.0},{1.0,0.0},{1.0,0.3},{0.0,0.6},{1.0,1.0}};
180 //lines
181 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
184
185 for (int i=0;i<5;++i) {
190 }
191 }
192
195 {
196 // S
197 //points
198 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.4},{1.0,0.6},{1.0,1.0},{0.0,1.0}};
199 //lines
200 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
203
204 for (int i=0;i<5;++i) {
209 }
210 }
211
214 {
215 // V
216 //points
217 float arr[3][2] = {{0.0,0.0},{0.5,1.0},{1.0,0.0}};
218 //lines
219 int arr2[2][2] = {{0,1},{1,2}};
222
223 for (int i=0;i<2;++i) {
228 }
229 }
230
233 {
234 // E
235 //points
236 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.5},{0.5,0.5},{0.0,1.0},{1.0,1.0}};
237 //lines
238 int arr2[4][2] = {{0,1},{1,2},{2,3},{4,5}};
241
242 for (int i=0;i<4;++i) {
247 }
248 }
249
252 {
253 // N
254 //points
255 float arr[6][2] = {{0.0,0.0},{0.0,1.0},{1.0,0.0},{1.0,1.0},{0.0,0.0},{1.0,1.0}};
256 //lines
257 int arr2[3][2] = {{0,1},{2,3},{4,5}};

260
261 for (int i=0;i<3;++i) {
266 }
267 }
268
271 {
272 // U
273 //points
274 float arr[4][2] = {{0.0,0.0},{0.0,1.0},{1.0,1.0},{1.0,0.5}};
275 //lines
276 int arr2[3][2] = {{0,1},{1,2},{2,3}};
279
280 for (int i=0;i<3;++i) {
285 }
286 }
287
290 {
291 // C
292 //points
293 float arr[4][2] = {{0.5,0.0},{0.0,0.0},{0.0,1.0},{1.0,1.0}};
294 //lines
295 int arr2[3][2] = {{0,1},{1,2},{2,3}};
298
299 for (int i=0;i<3;++i) {

304 }
305 }
306
309 {
310 // Y
311 //points
312 float arr[4][2] = {{0.5,0.6},{0.0,0.0},{1.0,0.0},{0.5,1.0}};
313 //lines
314 int arr2[3][2] = {{0,1},{0,2},{0,3}};
317
318 for (int i=0;i<3;++i) {
323 }
324 }
325
328 {
329 // P
330 //points
331 float arr[5][2] = {{0.0,1.0},{0.0,0.0},{1.0,0.0},{1.0,0.3},{0.0,0.6}};
332 //lines
333 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,4}};
336
337 for (int i=0;i<4;++i) {
342 }
343 }
344
347 {
348 // T
349 //points
350 float arr[3][2] = {{0.0,0.0},{1.0,0.0},{1.0,1.0}};
351 //lines
352 int arr2[2][2] = {{0,1},{1,2}};
355
356 for (int i=0;i<2;++i) {
361 }
362 }
363
366 t margin)
367 {
368 int x0 = 0;
370 int d = 3 - 2 * radius;
372
374 {
375 for (int i = sx; i <= ex; i++)
377 };
378
379 while (y0 >= x0)
380 {
381 drawline(x - x0, x + x0, y - y0);
382 drawline(x - y0, x + y0, y - x0);
383 drawline(x - x0, x + x0, y + y0);
384 drawline(x - y0, x + y0, y + x0);
385 if (d < 0) d += 4 * x0++ + 6;
386 else d += 4 * (x0++ - y0--) + 10;
387 }
388 }
389
391 {
394 }
395
398 }
399
401 > &coords)
402 {
404 dx = x2 - x1; dy = y2 - y1;
405 if (dx == 0)
406 {
407 if (y2 < y1) std::swap(y1, y2);
408 for (y = y1; y <= y2; y++)
410 return;
411 }
412 if (dy == 0)
413 {
414 if (x2 < x1) std::swap(x1, x2);
415 for (x = x1; x <= x2; x++)
417 return;
418 }
420 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
421 if (dy1 <= dx1)
422 {
423 if (dx >= 0)
424 {
425 x = x1; y = y1; xe = x2;
426 }
427 else
428 {
429 x = x2; y = y2; xe = x1;
430 }
432 for (i = 0; x<xe; i++)
433 {
434 x = x + 1;
435 if (px<0)
436 px = px + 2 * dy1;
437 else
438 {
440 px = px + 2 * (dy1 - dx1);
441 }
443 }
444 }
445 else
446 {
447 if (dy >= 0)
448 {
449 x = x1; y = y1; ye = y2;
450 }
451 else
452 {
453 x = x2; y = y2; ye = y1;
454 }
456 for (i = 0; y<ye; i++)
457 {
458 y = y + 1;
459 if (py <= 0)
460 py = py + 2 * dx1;
461 else
462 {
464 py = py + 2 * (dx1 - dy1);
465 }
467 }
468 }
469 }
470

474 {
476
481 do
482 {
484 ang+=0.001;
487 }
489
492
495
500
502 {
506 }
507 }
510 xs.clear();
511 }
512
514 {
515 for (int i = sx; i <= ex; i++)

517 };
518
521 }
522 }
523
526 {
530 dl;
531
533 {
534 color=image[i];
536 std::get<2>(color)*255.0f);
537 }
538 out.close();
539 }
540
544 {
548 , 0.0f, 0.0f);
549 } else {
551 t,margin);
552 }
553 }
554 }
555
556 int main()
557 {

562 int margin=0;
563 int linesize=2;
564 int fwidth=0;
565 int fheight=20;
566
567 get_width_from_height(fwidth,fheight);
568 get_margin_from_height(margin,fheight);
569
570 std::tuple<float,float,float> color1=std::make_tuple(1.0f,1.0f,1.0f);
571 std::tuple<float,float,float> color2=std::make_tuple(0.262745098f, 0.262745098f, 0.\
572 262745098f);
574 std::tuple<float,float,float> color4=std::make_tuple(0.968627451f,0.5882352941f,0.3\
575 607843137f);
576
577 std::vector<std::tuple<float, float, float>> f_m;
578 f_m.resize(calc_size(fwidth, fheight, margin));
579 clear_image(f_m,fwidth,fheight,margin);
580 draw_font_M(points,color2,fwidth,fheight,margin);
581 draw(points,f_m,color2,fwidth,fheight,margin,linesize);
582 points.clear();
583 std::vector<std::tuple<float, float, float>> f_a;
584 f_a.resize(calc_size(fwidth, fheight, margin));
585 clear_image(f_a,fwidth,fheight,margin);
586 draw_font_A(points,color2,fwidth,fheight,margin);
587 draw(points,f_a,color2,fwidth,fheight,margin,linesize);
588 points.clear();
589 std::vector<std::tuple<float, float, float>> f_r;
590 f_r.resize(calc_size(fwidth, fheight, margin));
591 clear_image(f_r,fwidth,fheight,margin);
592 draw_font_R(points,color2,fwidth,fheight,margin);
593 draw(points,f_r,color2,fwidth,fheight,margin,linesize);
594 points.clear();
595 std::vector<std::tuple<float, float, float>> f_s;
596 f_s.resize(calc_size(fwidth, fheight, margin));
597 clear_image(f_s,fwidth,fheight,margin);
598 draw_font_S(points,color2,fwidth,fheight,margin);
599 draw(points,f_s,color2,fwidth,fheight,margin,linesize);
600 points.clear();
601 std::vector<std::tuple<float, float, float>> f_v;
602 f_v.resize(calc_size(fwidth, fheight, margin));

603 clear_image(f_v,fwidth,fheight,margin);
604 draw_font_V(points,color2,fwidth,fheight,margin);
605 draw(points,f_v,color2,fwidth,fheight,margin,linesize);
606 points.clear();
607 std::vector<std::tuple<float, float, float>> f_e;
608 f_e.resize(calc_size(fwidth, fheight, margin));
609 clear_image(f_e,fwidth,fheight,margin);
610 draw_font_E(points,color2,fwidth,fheight,margin);
611 draw(points,f_e,color2,fwidth,fheight,margin,linesize);
612 points.clear();
613 std::vector<std::tuple<float, float, float>> f_n;
614 f_n.resize(calc_size(fwidth, fheight, margin));
615 clear_image(f_n,fwidth,fheight,margin);
616 draw_font_N(points,color2,fwidth,fheight,margin);
617 draw(points,f_n,color2,fwidth,fheight,margin,linesize);
618 points.clear();
619 std::vector<std::tuple<float, float, float>> f_u;
620 f_u.resize(calc_size(fwidth, fheight, margin));
621 clear_image(f_u,fwidth,fheight,margin);
622 draw_font_U(points,color2,fwidth,fheight,margin);
623 draw(points,f_u,color2,fwidth,fheight,margin,linesize);
624 points.clear();
625 std::vector<std::tuple<float, float, float>> f_c;
626 f_c.resize(calc_size(fwidth, fheight, margin));
627 clear_image(f_c,fwidth,fheight,margin);
628 draw_font_C(points,color2,fwidth,fheight,margin);
629 draw(points,f_c,color2,fwidth,fheight,margin,linesize);
630 points.clear();
631 std::vector<std::tuple<float, float, float>> f_y;
632 f_y.resize(calc_size(fwidth, fheight, margin));
633 clear_image(f_y,fwidth,fheight,margin);
634 draw_font_Y(points,color2,fwidth,fheight,margin);
635 draw(points,f_y,color2,fwidth,fheight,margin,linesize);
636 points.clear();
637 std::vector<std::tuple<float, float, float>> f_p;
638 f_p.resize(calc_size(fwidth, fheight, margin));
639 clear_image(f_p,fwidth,fheight,margin);
640 draw_font_P(points,color2,fwidth,fheight,margin);
641 draw(points,f_p,color2,fwidth,fheight,margin,linesize);
642 points.clear();
643 std::vector<std::tuple<float, float, float>> f_t;
644 f_t.resize(calc_size(fwidth, fheight, margin));
645 clear_image(f_t,fwidth,fheight,margin);
646 draw_font_T(points,color2,fwidth,fheight,margin);
647 draw(points,f_t,color2,fwidth,fheight,margin,linesize);
648 points.clear();
649
652
653 draw_filled_wedge(width/2,height/2,(height/2)*0.5,0,90,image,color1,width,height);
654 draw_filled_wedge(width/2,height/2,(height/2)*0.5,90,180,image,color2,width,height);
655 draw_filled_wedge(width/2,height/2,(height/2)*0.5,180,270,image,color3,width,height\
656 );
657 draw_filled_wedge(width/2,height/2,(height/2)*0.5,270,360,image,color4,width,height\
658 );
659
660 stamp(image,f_m,330,303,(fwidth+margin),(fheight+margin),width);
661 stamp(image,f_a,330+(1*(fwidth+margin)),303,(fwidth+margin),(fheight+margin),width);
662 stamp(image,f_r,330+(2*(fwidth+margin)),303,(fwidth+margin),(fheight+margin),width);
663 stamp(image,f_s,330+(3*(fwidth+margin)),303,(fwidth+margin),(fheight+margin),width);
664
665 stamp(image,f_v,330,554,(fwidth+margin),(fheight+margin),width);
666 stamp(image,f_e,330+(1*(fwidth+margin)),554,(fwidth+margin),(fheight+margin),width);
667 stamp(image,f_n,330+(2*(fwidth+margin)),554,(fwidth+margin),(fheight+margin),width);
668 stamp(image,f_u,330+(3*(fwidth+margin)),554,(fwidth+margin),(fheight+margin),width);
670
672 stamp(image,f_e,1100+(1*(fwidth+margin)),303,(fwidth+margin),(fheight+margin),width\
673 );
674 stamp(image,f_r,1100+(2*(fwidth+margin)),303,(fwidth+margin),(fheight+margin),width\
675 );
676 stamp(image,f_c,1100+(3*(fwidth+margin)),303,(fwidth+margin),(fheight+margin),width\
677 );
678 stamp(image,f_u,1100+(4*(fwidth+margin)),303,(fwidth+margin),(fheight+margin),width\
679 );
680 stamp(image,f_r,1100+(5*(fwidth+margin)),303,(fwidth+margin),(fheight+margin),width\
681 );
682 stamp(image,f_y,1100+(6*(fwidth+margin)),303,(fwidth+margin),(fheight+margin),width\
683 );
684
685 stamp(image,f_n,1100,554,(fwidth+margin),(fheight+margin),width);
687 );
688 stamp(image,f_p,1100+(2*(fwidth+margin)),554,(fwidth+margin),(fheight+margin),width\
689 );
690 stamp(image,f_t,1100+(3*(fwidth+margin)),554,(fwidth+margin),(fheight+margin),width\
691 );
692 stamp(image,f_u,1100+(4*(fwidth+margin)),554,(fwidth+margin),(fheight+margin),width\
693 );
694 stamp(image,f_n,1100+(5*(fwidth+margin)),554,(fwidth+margin),(fheight+margin),width\
695 );
697 );
698
699 std::cout << "saving: 16_draw_pie_chart.ppm." << std::endl;
700 save_image(image,width,height,"16_draw_pie_chart.ppm");
701
702 return 0;
703 }
16_draw_donut_chart.cpp - 24586 bytes.
1 // Compile: clang++ -std=c++17 16_draw_donut_chart.cpp -o 16_draw_donut_chart

3
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
11
13 {
16 }
17
19 {
21 }
22
24 {
26 }
27
29 {
31 }
32
36 {
37 int inputx=0;
38 int inputy=0;
40 {
42 {
44 inputx++;
45 }
46 inputy++;
47 inputx=0;
48 }
49 }
50
53 {
57 118f);
58 }
59 }
60 }
61
63 int, int> &coords, std::tuple<float,float,float> &color, int width, int height)
64 {
68 dx = x2 - x1; dy = y2 - y1;
69 if (dx == 0)
70 {
71 if (y2 < y1) std::swap(y1, y2);
72 for (y = y1; y <= y2; y++)
74 return;
75 }
76 if (dy == 0)
77 {
78 if (x2 < x1) std::swap(x1, x2);
79 for (x = x1; x <= x2; x++)
81 return;
82 }
84 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
85 if (dy1 <= dx1)
86 {
87 if (dx >= 0)
88 {
89 x = x1; y = y1; xe = x2;
90 }
91 else
92 {
93 x = x2; y = y2; xe = x1;
94 }
96 for (i = 0; x<xe; i++)
97 {
98 x = x + 1;
99 if (px<0)
100 px = px + 2 * dy1;
101 else
102 {
104 px = px + 2 * (dy1 - dx1);
105 }
107 }
108 }
109 else
110 {
111 if (dy >= 0)

112 {
113 x = x1; y = y1; ye = y2;
114 }
115 else
116 {
117 x = x2; y = y2; ye = y1;
118 }
120 for (i = 0; y<ye; i++)
121 {
122 y = y + 1;
123 if (py <= 0)
124 py = py + 2 * dx1;
125 else
126 {
128 py = py + 2 * (dx1 - dy1);
129 }
131 }
132 }
133 }
134
137 {
138 // M
139 //points
140 float arr[5][2] = {{0.0,1.0},{0.0,0.0},{0.5,0.3},{1.0,0.0},{1.0,1.0}};
141 //lines
142 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,4}};
145
146 for (int i=0;i<4;++i) {
150 get_line_points(points,coords,color,width,height);
151 }
152 }
153

156 {
157 // A
158 //points
159 float arr[4][2] = {{0.0,1.0},{0.5,0.0},{1.0,1.0},{0.0,0.6}};
160 //lines
161 int arr2[3][2] = {{0,1},{1,2},{2,3}};
164
165 for (int i=0;i<3;++i) {
170 }
171 }
172
175 {
176 // R
177 //points
178 float arr[6][2] = {{0.0,1.0},{0.0,0.0},{1.0,0.0},{1.0,0.3},{0.0,0.6},{1.0,1.0}};
179 //lines
180 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
183
184 for (int i=0;i<5;++i) {
189 }
190 }
191
194 {
195 // S
196 //points
197 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.4},{1.0,0.6},{1.0,1.0},{0.0,1.0}};

198 //lines
199 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
202
203 for (int i=0;i<5;++i) {
208 }
209 }
210
213 {
214 // V
215 //points
216 float arr[3][2] = {{0.0,0.0},{0.5,1.0},{1.0,0.0}};
217 //lines
218 int arr2[2][2] = {{0,1},{1,2}};
221
222 for (int i=0;i<2;++i) {
227 }
228 }
229
232 {
233 // E
234 //points
235 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.5},{0.5,0.5},{0.0,1.0},{1.0,1.0}};
236 //lines
237 int arr2[4][2] = {{0,1},{1,2},{2,3},{4,5}};
240
241 for (int i=0;i<4;++i) {
246 }
247 }
248
251 {
252 // N
253 //points
254 float arr[6][2] = {{0.0,0.0},{0.0,1.0},{1.0,0.0},{1.0,1.0},{0.0,0.0},{1.0,1.0}};
255 //lines
256 int arr2[3][2] = {{0,1},{2,3},{4,5}};
259
260 for (int i=0;i<3;++i) {
265 }
266 }
267
270 {
271 // U
272 //points
273 float arr[4][2] = {{0.0,0.0},{0.0,1.0},{1.0,1.0},{1.0,0.5}};
274 //lines
275 int arr2[3][2] = {{0,1},{1,2},{2,3}};
278
279 for (int i=0;i<3;++i) {
284 }
285 }
286
289 {
290 // C
291 //points
292 float arr[4][2] = {{0.5,0.0},{0.0,0.0},{0.0,1.0},{1.0,1.0}};
293 //lines
294 int arr2[3][2] = {{0,1},{1,2},{2,3}};
297
298 for (int i=0;i<3;++i) {
303 }
304 }
305
308 {
309 // Y
310 //points
311 float arr[4][2] = {{0.5,0.6},{0.0,0.0},{1.0,0.0},{0.5,1.0}};
312 //lines
313 int arr2[3][2] = {{0,1},{0,2},{0,3}};
316
317 for (int i=0;i<3;++i) {
322 }
323 }
324

327 {
328 // P
329 //points
330 float arr[5][2] = {{0.0,1.0},{0.0,0.0},{1.0,0.0},{1.0,0.3},{0.0,0.6}};
331 //lines
332 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,4}};
335
336 for (int i=0;i<4;++i) {
341 }
342 }
343
346 {
347 // T
348 //points
349 float arr[3][2] = {{0.0,0.0},{1.0,0.0},{1.0,1.0}};
350 //lines
351 int arr2[2][2] = {{0,1},{1,2}};
354
355 for (int i=0;i<2;++i) {
360 }
361 }
362
365 t margin)
366 {
367 int x0 = 0;
369 int d = 3 - 2 * radius;

371
373 {
374 for (int i = sx; i <= ex; i++)
376 };
377
378 while (y0 >= x0)
379 {
380 drawline(x - x0, x + x0, y - y0);
381 drawline(x - y0, x + y0, y - x0);
382 drawline(x - x0, x + x0, y + y0);
383 drawline(x - y0, x + y0, y + x0);
384 if (d < 0) d += 4 * x0++ + 6;
385 else d += 4 * (x0++ - y0--) + 10;
386 }
387 }
388
389 void draw_filled_circle2(int x, int y, int radius, std::vector<std::tuple<float, flo\
390 at, float>> &image, std::tuple<float, float, float> &color, int width, int height)
391 {
392 int x0 = 0;
394 int d = 3 - 2 * radius;
396
398 {
399 for (int i = sx; i <= ex; i++)
401 };
402
403 while (y0 >= x0)
404 {
405 drawline(x - x0, x + x0, y - y0);
406 drawline(x - y0, x + y0, y - x0);
407 drawline(x - x0, x + x0, y + y0);
408 drawline(x - y0, x + y0, y + x0);
409 if (d < 0) d += 4 * x0++ + 6;
410 else d += 4 * (x0++ - y0--) + 10;
411 }
412 }
413
415 {
418 }
419
422 }
423
425 > &coords)
426 {
428 dx = x2 - x1; dy = y2 - y1;
429 if (dx == 0)
430 {
431 if (y2 < y1) std::swap(y1, y2);
432 for (y = y1; y <= y2; y++)
434 return;
435 }
436 if (dy == 0)
437 {
438 if (x2 < x1) std::swap(x1, x2);
439 for (x = x1; x <= x2; x++)
441 return;
442 }
444 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
445 if (dy1 <= dx1)
446 {
447 if (dx >= 0)
448 {
449 x = x1; y = y1; xe = x2;
450 }
451 else
452 {
453 x = x2; y = y2; xe = x1;
454 }
456 for (i = 0; x<xe; i++)
457 {
458 x = x + 1;
459 if (px<0)
460 px = px + 2 * dy1;
461 else
462 {
464 px = px + 2 * (dy1 - dx1);
465 }
467 }
468 }
469 else
470 {
471 if (dy >= 0)
472 {
473 x = x1; y = y1; ye = y2;
474 }
475 else
476 {
477 x = x2; y = y2; ye = y1;
478 }
480 for (i = 0; y<ye; i++)
481 {
482 y = y + 1;
483 if (py <= 0)
484 py = py + 2 * dx1;
485 else
486 {
488 py = py + 2 * (dx1 - dy1);
489 }
491 }
492 }
493 }
494
498 {
500
505 do
506 {
508 ang+=0.001;
511 }
513
516
519
524
526 {
530 }
531 }
534 xs.clear();
535 }
536
538 {
539 for (int i = sx; i <= ex; i++)
541 };
542
545 }
546 }
547
550 {
554 dl;
555
557 {
558 color=image[i];
560 std::get<2>(color)*255.0f);
561 }
562 out.close();
563 }
564
568 {
572 , 0.0f, 0.0f);
573 } else {
575 t,margin);
576 }
577 }
578 }
579
580 void draw2(std::vector<std::tuple<int,int>> points,std::vector<std::tuple<float, flo\
581 at, float>> &image, std::tuple<float,float,float> color, int width, int height, int
582 linesize)
583 {

586 image[get_index(std::get<0>(p),std::get<1>(p),width)]=std::make_tuple(0.0f,
587 0.0f);
588 } else {
589 draw_filled_circle2(std::get<0>(p),std::get<1>(p),linesize,image,color,width
590 ht);
591 }
592 }
593 }
594
595 int main()
596 {
601 int margin=0;
602 int linesize=2;
603 int fwidth=0;
604 int fheight=20;
605 int label_x=0;
606
609 label_x=(fwidth+margin)/2;
610
612 8f);
614 607843137f);
615 std::tuple<float,float,float> color2=std::make_tuple(0.262745098f, 0.262745098f, 0.\
616 262745098f);
617
623 points.clear();
629 points.clear();
635 points.clear();
641 points.clear();
642 std::vector<std::tuple<float, float, float>> f_v;
643 f_v.resize(calc_size(fwidth, fheight, margin));
644 clear_image(f_v,fwidth,fheight,margin);
645 draw_font_V(points,color2,fwidth,fheight,margin);
646 draw(points,f_v,color2,fwidth,fheight,margin,linesize);
647 points.clear();
653 points.clear();
659 points.clear();
665 points.clear();
671 points.clear();
677 points.clear();
678 std::vector<std::tuple<float, float, float>> f_p;
679 f_p.resize(calc_size(fwidth, fheight, margin));
680 clear_image(f_p,fwidth,fheight,margin);
681 draw_font_P(points,color2,fwidth,fheight,margin);
682 draw(points,f_p,color2,fwidth,fheight,margin,linesize);
683 points.clear();
689 points.clear();
690
693
694 // 320, 640, 960, 1280
695 draw_filled_circle2(320,height*0.4,92,image,color1,width,height);
698 draw_filled_wedge(320,height*0.4,62,0,360,image,color2,width,height);
700 coords=std::make_tuple(320,436,320,436+38);
701 get_line_points(points,coords,color2,width,height);
702 draw2(points,image,color2,width,height,3);
703 draw_filled_circle2(320,436+38+8,8,image,color2,width,height);
705
716
727
738
739 // Labels
740 stamp(image,f_m,320-(4*label_x),512,(fwidth+margin),(fheight+margin),width);
741 stamp(image,f_a,320-(4*label_x)+(1*(fwidth+margin)),512,(fwidth+margin),(fheight+ma\
742 rgin),width);
743 stamp(image,f_r,320-(4*label_x)+(2*(fwidth+margin)),512,(fwidth+margin),(fheight+ma\
744 rgin),width);
745 stamp(image,f_s,320-(4*label_x)+(3*(fwidth+margin)),512,(fwidth+margin),(fheight+ma\
746 rgin),width);
747
748 stamp(image,f_v,640-(5*label_x),512,(fwidth+margin),(fheight+margin),width);
749 stamp(image,f_e,640-(5*label_x)+(1*(fwidth+margin)),512,(fwidth+margin),(fheight+ma\
750 rgin),width);
751 stamp(image,f_n,640-(5*label_x)+(2*(fwidth+margin)),512,(fwidth+margin),(fheight+ma\
752 rgin),width);
753 stamp(image,f_u,640-(5*label_x)+(3*(fwidth+margin)),512,(fwidth+margin),(fheight+ma\
754 rgin),width);
755 stamp(image,f_s,640-(5*label_x)+(4*(fwidth+margin)),512,(fwidth+margin),(fheight+ma\
756 rgin),width);
757
758 stamp(image,f_n,960-(7*label_x),512,(fwidth+margin),(fheight+margin),width);
760 rgin),width);
761 stamp(image,f_p,960-(7*label_x)+(2*(fwidth+margin)),512,(fwidth+margin),(fheight+ma\
762 rgin),width);
763 stamp(image,f_t,960-(7*label_x)+(3*(fwidth+margin)),512,(fwidth+margin),(fheight+ma\
764 rgin),width);
765 stamp(image,f_u,960-(7*label_x)+(4*(fwidth+margin)),512,(fwidth+margin),(fheight+ma\
766 rgin),width);
767 stamp(image,f_n,960-(7*label_x)+(5*(fwidth+margin)),512,(fwidth+margin),(fheight+ma\
768 rgin),width);
770 rgin),width);
771
772 stamp(image,f_m,1280-(7*label_x),512,(fwidth+margin),(fheight+margin),width);
773 stamp(image,f_e,1280-(7*label_x)+(1*(fwidth+margin)),512,(fwidth+margin),(fheight+m\
774 argin),width);
775 stamp(image,f_r,1280-(7*label_x)+(2*(fwidth+margin)),512,(fwidth+margin),(fheight+m\
776 argin),width);
777 stamp(image,f_c,1280-(7*label_x)+(3*(fwidth+margin)),512,(fwidth+margin),(fheight+m\
778 argin),width);
779 stamp(image,f_u,1280-(7*label_x)+(4*(fwidth+margin)),512,(fwidth+margin),(fheight+m\
780 argin),width);
781 stamp(image,f_r,1280-(7*label_x)+(5*(fwidth+margin)),512,(fwidth+margin),(fheight+m\
782 argin),width);
783 stamp(image,f_y,1280-(7*label_x)+(6*(fwidth+margin)),512,(fwidth+margin),(fheight+m\
784 argin),width);
785
786 std::cout << "saving: 16_draw_donut_chart.ppm." << std::endl;
787 save_image(image,width,height,"16_draw_donut_chart.ppm");
788
789 return 0;
790 }
16_draw_table.cpp - 29528 bytes.

1 // Compile: clang++ -std=c++17 16_draw_table.cpp -o 16_draw_table
2
5 #include <tuple>
6 #include <vector>
7 #include <random>
8 #include <cmath>
9
11 {
14 }
15
17 {
19 }
20
22 {
24 }
25
27 {
29 }
30
33 {
37 118f);
38 }
39 }
40 }
41
45 {
46 int inputx=0;
47 int inputy=0;
49 {
51 {
53 inputx++;
54 }
55 inputy++;
56 inputx=0;
57 }
58 }
59
61 int, int> &coords, std::tuple<float,float,float> &color, int width, int height)
62 {
66 dx = x2 - x1; dy = y2 - y1;
67 if (dx == 0)
68 {
69 if (y2 < y1) std::swap(y1, y2);
70 for (y = y1; y <= y2; y++)
72 return;
73 }
74 if (dy == 0)
75 {
76 if (x2 < x1) std::swap(x1, x2);
77 for (x = x1; x <= x2; x++)
79 return;
80 }
82 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
83 if (dy1 <= dx1)
84 {
85 if (dx >= 0)
86 {
87 x = x1; y = y1; xe = x2;
88 }
89 else
90 {
91 x = x2; y = y2; xe = x1;
92 }
94 for (i = 0; x<xe; i++)
95 {
96 x = x + 1;
97 if (px<0)
98 px = px + 2 * dy1;
99 else
100 {
102 px = px + 2 * (dy1 - dx1);
103 }
105 }
106 }
107 else
108 {
109 if (dy >= 0)
110 {
111 x = x1; y = y1; ye = y2;
112 }
113 else
114 {
115 x = x2; y = y2; ye = y1;
116 }
118 for (i = 0; y<ye; i++)
119 {
120 y = y + 1;
121 if (py <= 0)
122 py = py + 2 * dx1;
123 else
124 {
126 py = py + 2 * (dx1 - dy1);
127 }
129 }
130 }
131 }
132
135 {
136 // M
137 //points
138 float arr[5][2] = {{0.0,1.0},{0.0,0.0},{0.5,0.3},{1.0,0.0},{1.0,1.0}};
139 //lines
140 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,4}};
143
144 for (int i=0;i<4;++i) {
149 }
150 }
151
154 {
155 // A
156 //points
157 float arr[4][2] = {{0.0,1.0},{0.5,0.0},{1.0,1.0},{0.0,0.6}};
158 //lines
159 int arr2[3][2] = {{0,1},{1,2},{2,3}};
162
163 for (int i=0;i<3;++i) {
168 }
169 }
170

173 {
174 // R
175 //points
176 float arr[6][2] = {{0.0,1.0},{0.0,0.0},{1.0,0.0},{1.0,0.3},{0.0,0.6},{1.0,1.0}};
177 //lines
178 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
181
182 for (int i=0;i<5;++i) {
187 }
188 }
189
192 {
193 // S
194 //points
195 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.4},{1.0,0.6},{1.0,1.0},{0.0,1.0}};
196 //lines
197 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
200
201 for (int i=0;i<5;++i) {
206 }
207 }
208
211 {
212 // E
213 //points
214 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.5},{0.5,0.5},{0.0,1.0},{1.0,1.0}};
215 //lines
216 int arr2[4][2] = {{0,1},{1,2},{2,3},{4,5}};
219
220 for (int i=0;i<4;++i) {
225 }
226 }
227
230 {
231 // U
232 //points
233 float arr[4][2] = {{0.0,0.0},{0.0,1.0},{1.0,1.0},{1.0,0.5}};
234 //lines
235 int arr2[3][2] = {{0,1},{1,2},{2,3}};
238
239 for (int i=0;i<3;++i) {
244 }
245 }
246
249 {
250 // C
251 //points
252 float arr[4][2] = {{0.5,0.0},{0.0,0.0},{0.0,1.0},{1.0,1.0}};
253 //lines
254 int arr2[3][2] = {{0,1},{1,2},{2,3}};
257
258 for (int i=0;i<3;++i) {

263 }
264 }
265
268 {
269 // Y
270 //points
271 float arr[4][2] = {{0.5,0.6},{0.0,0.0},{1.0,0.0},{0.5,1.0}};
272 //lines
273 int arr2[3][2] = {{0,1},{0,2},{0,3}};
276
277 for (int i=0;i<3;++i) {
282 }
283 }
284
287 {
288 // T
289 //points
290 float arr[3][2] = {{0.0,0.0},{1.0,0.0},{1.0,1.0}};
291 //lines
292 int arr2[2][2] = {{0,1},{1,2}};
295
296 for (int i=0;i<2;++i) {
301 }
302 }
303
306 {
307 // N
308 //points
309 float arr[6][2] = {{0.0,0.0},{0.0,1.0},{1.0,0.0},{1.0,1.0},{0.0,0.0},{1.0,1.0}};
310 //lines
311 int arr2[3][2] = {{0,1},{2,3},{4,5}};
314
315 for (int i=0;i<3;++i) {
320 }
321 }
322
325 {
326 // 0
327 //points
328 float arr[6][2] = {{0.0,0.0},{0.0,1.0},{1.0,1.0},{1.0,0.0},{0.0,1.0},{1.0,0.0}};
329 //lines
330 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,0},{4,5}};
333
334 for (int i=0;i<5;++i) {
339 }
340 }
341
344 {
345 // 1
346 //points
347 float arr[3][2] = {{0.0,0.0},{0.5,0.0},{0.5,1.0}};
348 //lines
349 int arr2[2][2] = {{0,1},{1,2}};
352
353 for (int i=0;i<2;++i) {
358 }
359 }
360
363 {
364 // 2
365 //points
366 float arr[6][2] = {{0.0,0.0},{1.0,0.0},{1.0,0.4},{0.0,0.6},{0.0,1.0},{1.0,1.0}};
367 //lines
368 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
371
372 for (int i=0;i<5;++i) {
377 }
378 }
379
382 {
383 // 3
384 //points
385 float arr[6][2] = {{0.0,0.0},{1.0,0.0},{1.0,0.4},{0.5,0.4},{0.0,1.0},{1.0,1.0}};
386 //lines
387 int arr2[4][2] = {{0,1},{1,2},{2,3},{4,5}};

390
391 for (int i=0;i<4;++i) {
396 }
397 }
398
401 {
402 // 4
403 //points
404 float arr[5][2] = {{0.0,0.0},{0.0,0.4},{1.0,0.6},{1.0,0.0},{1.0,1.0}};
405 //lines
406 int arr2[3][2] = {{0,1},{1,2},{3,4}};
409
410 for (int i=0;i<3;++i) {
415 }
416 }
417
420 {
421 // 5
422 //points
423 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.5},{1.0,0.6},{1.0,1.0},{0.0,1.0}};
424 //lines
425 int arr2[5][2] = {{0,1},{1,2},{2,3},{3,4},{4,5}};
428
429 for (int i=0;i<5;++i) {

434 }
435 }
436
439 {
440 // 6
441 //points
442 float arr[6][2] = {{1.0,0.0},{0.0,0.0},{0.0,0.4},{1.0,0.6},{1.0,1.0},{0.0,1.0}};
443 //lines
444 int arr2[5][2] = {{0,1},{1,5},{5,4},{3,4},{3,2}};
447
448 for (int i=0;i<5;++i) {
453 }
454 }
455
458 {
459 // 7
460 //points
461 float arr[3][2] = {{0.0,0.0},{1.0,0.0},{1.0,1.0}};
462 //lines
463 int arr2[2][2] = {{0,1},{1,2}};
466
467 for (int i=0;i<2;++i) {
472 }
473 }
474
477 {
478 // 8
479 //points
480 float arr[6][2] = {{0.1,0.4},{0.9,0.6},{1.0,0.0},{0.0,0.0},{0.0,1.0},{1.0,1.0}};
481 //lines
482 int arr2[7][2] = {{0,1},{1,2},{2,3},{3,0},{0,4},{4,5},{5,1}};
485
486 for (int i=0;i<7;++i) {
491 }
492 }
493
496 {
497 // 9
498 //points
499 float arr[5][2] = {{1.0,1.0},{1.0,0.0},{0.0,0.0},{0.0,0.6},{1.0,0.4}};
500 //lines
501 int arr2[4][2] = {{0,1},{1,2},{2,3},{3,4}};
504
505 for (int i=0;i<4;++i) {
510 }
511 }
512
515 t margin)
516 {
517 int x0 = 0;
519 int d = 3 - 2 * radius;
521
523 {
524 for (int i = sx; i <= ex; i++)
526 };
527
528 while (y0 >= x0)
529 {
530 drawline(x - x0, x + x0, y - y0);
531 drawline(x - y0, x + y0, y - x0);
532 drawline(x - x0, x + x0, y + y0);
533 drawline(x - y0, x + y0, y + x0);
534 if (d < 0) d += 4 * x0++ + 6;
535 else d += 4 * (x0++ - y0--) + 10;
536 }
537 }
538
541 {
542 int x2 = x + w;
543 int y2 = y + h;
544
545 if (x < 0) {x = 0;}
547 if (y < 0) {y = 0;}
549
550 if (x2 < 0) {x2 = 0;}
552 if (y2 < 0) {y2 = 0;}
554
555 for (int i = y; i < y2; i++) {
556 for (int j = x; j < x2; j++) {
558 }
559 }
560 }
561
564 {
568 dl;
569
571 {
572 color=image[i];
574 std::get<2>(color)*255.0f);
575 }
576 out.close();
577 }
578
582 {
585 image[get_index(std::get<0>(p),std::get<1>(p),width+margin)]=color;
586 } else {
588 t,margin);
589 }
590 }
591 }
592
593 int main()
594 {
599 2745098f);
602 int margin=0;

603 int linesize=1;
604 int fwidth=0;
605 int fheight=10;
606
609
612
618 points.clear();
624 points.clear();
630 points.clear();
636 points.clear();
642 points.clear();
648 points.clear();
654 points.clear();
660 points.clear();
666 points.clear();
672 points.clear();
673 std::vector<std::tuple<float, float, float>> f_1;
674 f_1.resize(calc_size(fwidth, fheight, margin));
675 clear_image(f_1,fwidth,fheight,margin);
676 draw_font_1(points,color3,fwidth,fheight,margin);
677 draw(points,f_1,color3,fwidth,fheight,margin,linesize);
678 points.clear();
684 points.clear();
690 points.clear();
691
692 std::vector<std::tuple<float, float, float>> f_w0;
693 f_w0.resize(calc_size(fwidth, fheight, margin));
694 clear_image(f_w0,fwidth,fheight,margin);
696 draw(points,f_w0,color2,fwidth,fheight,margin,linesize);
697 points.clear();
703 points.clear();
709 points.clear();
715 points.clear();
721 points.clear();
727 points.clear();
733 points.clear();
739 points.clear();
745 points.clear();
751 points.clear();
752
753 draw_filled_rect(402,322,796,5,image,color1,width,height);
763
764 // Labels
766 stamp(image,f_e,420+(1*(fwidth+margin)),460,(fwidth+margin),(fheight+margin),width);
768 stamp(image,f_c,420+(3*(fwidth+margin)),460,(fwidth+margin),(fheight+margin),width);
771 stamp(image,f_y,420+(6*(fwidth+margin)),460,(fwidth+margin),(fheight+margin),width);
772
777
778 stamp(image,f_s,426,660,(fwidth+margin),(fheight+margin),width);
780 stamp(image,f_t,426+(2*(fwidth+margin)),660,(fwidth+margin),(fheight+margin),width);
783 stamp(image,f_n,426+(5*(fwidth+margin)),660,(fwidth+margin),(fheight+margin),width);
784
785 stamp(image,f_a,646,370,(fwidth+margin),(fheight+margin),width);
786 stamp(image,f_1,646+(1*(fwidth+margin)),370,(fwidth+margin),(fheight+margin),width);
787
789 stamp(image,f_2,846+(1*(fwidth+margin)),370,(fwidth+margin),(fheight+margin),width);
790
792 stamp(image,f_3,1056+(1*(fwidth+margin)),370,(fwidth+margin),(fheight+margin),width\
793 );
794
795 stamp(image,f_w1,626,460,(fwidth+margin),(fheight+margin),width);
796 stamp(image,f_w0,626+(1*(fwidth+margin)),460,(fwidth+margin),(fheight+margin),width\
797 );
799 );
801 );
802
805 );
807 );
809 );
810
812 stamp(image,f_w8,1036+(1*(fwidth+margin)),460,(fwidth+margin),(fheight+margin),widt\
813 h);
815 h);
817 h);
819 h);
820
823 );
824
827 );
829 );
830
833 h);
835 h);
837 h);
838
841 );
843 );
845 );
846
849 );
851 );
853 );
854
857 h);
859 h);
861 h);
862
863 std::cout << "saving: 16_draw_table.ppm." << std::endl;
864 save_image(image,width,height,"16_draw_table.ppm");
865
866 return 0;
867 }
16_draw_market_size.cpp - 104365 bytes.
1 // Compile: clang++ -std=c++17 16_draw_market_size.cpp -o 16_draw_market_size

2
5 #include <tuple>
6 #include <vector>
7 #include <random>
8 #include <cmath>
10
12 {
14 }
15
17 {
19 }
20
21 void flood_fill(std::vector<std::tuple<float, float, float>> &image, int x, int y, s\
22 td::tuple<float,float,float> &oldcolor, std::tuple<float,float,float> &newcolor, int
23 width)
24 {
25 if(image[get_index(x,y,width)] == oldcolor)
26 {
27 image[get_index(x,y,width)]=newcolor;
28 flood_fill(image,x+1,y,oldcolor,newcolor,width);
29 flood_fill(image,x,y+1,oldcolor,newcolor,width);
30 flood_fill(image,x-1,y,oldcolor,newcolor,width);
31 flood_fill(image,x,y-1,oldcolor,newcolor,width);
32 }
33 }
34
37 {
41 dx = x2 - x1; dy = y2 - y1;
42
43 if (dx == 0)
44 {
45 if (y2 < y1) std::swap(y1, y2);
46 for (y = y1; y <= y2; y++)
48 return;
49 }
50 if (dy == 0)
51 {
52 if (x2 < x1) std::swap(x1, x2);
53 for (x = x1; x <= x2; x++)
55 return;
56 }
58 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
59 if (dy1 <= dx1)
60 {
61 if (dx >= 0)
62 {
63 x = x1; y = y1; xe = x2;
64 }
65 else
66 {
67 x = x2; y = y2; xe = x1;
68 }
70 for (i = 0; x<xe; i++)
71 {
72 x = x + 1;
73 if (px<0)
74 px = px + 2 * dy1;
75 else
76 {
78 px = px + 2 * (dy1 - dx1);
79 }
81 }
82 }
83 else
84 {
85 if (dy >= 0)
86 {
87 x = x1; y = y1; ye = y2;
88 }
89 else
90 {
91 x = x2; y = y2; ye = y1;
92 }
94 for (i = 0; y<ye; i++)
95 {
96 y = y + 1;
97 if (py <= 0)
98 py = py + 2 * dx1;
99 else
100 {
102 py = py + 2 * (dx1 - dy1);
103 }
105 }
106 }
107 }
108
111 {
112 int x0 = 0;
114 int d = 3 - 2 * radius;
116
118 {
119 // uncomment if on windows

120 //if (((sx>=0)&&(sx<width)) && ((ex>=0)&&(ex<width)) && ((ny>=0)&&(ny<height))) {
121 for (int i = sx; i <= ex; i++) {
123 }
124 //}
125 };
126
127 while (y0 >= x0)
128 {
129 drawline(x - x0, x + x0, y - y0);
130 drawline(x - y0, x + y0, y - x0);
131 drawline(x - x0, x + x0, y + y0);
132 drawline(x - y0, x + y0, y + x0);
133 if (d < 0) d += 4 * x0++ + 6;
134 else d += 4 * (x0++ - y0--) + 10;
135 }
136 }
137
139 int, int> &coords)
140 {
144 dx = x2 - x1; dy = y2 - y1;
145 if (dx == 0)
146 {
147 if (y2 < y1) std::swap(y1, y2);
148 for (y = y1; y <= y2; y++)
150 return;
151 }
152 if (dy == 0)
153 {
154 if (x2 < x1) std::swap(x1, x2);
155 for (x = x1; x <= x2; x++)
157 return;
158 }
160 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
161 if (dy1 <= dx1)
162 {
163 if (dx >= 0)
164 {
165 x = x1; y = y1; xe = x2;
166 }
167 else
168 {
169 x = x2; y = y2; xe = x1;
170 }
172 for (i = 0; x<xe; i++)
173 {
174 x = x + 1;
175 if (px<0)
176 px = px + 2 * dy1;
177 else
178 {
180 px = px + 2 * (dy1 - dx1);
181 }
183 }
184 }
185 else
186 {
187 if (dy >= 0)
188 {
189 x = x1; y = y1; ye = y2;
190 }
191 else
192 {
193 x = x2; y = y2; ye = y1;
194 }
196 for (i = 0; y<ye; i++)
197 {
198 y = y + 1;
199 if (py <= 0)
200 py = py + 2 * dx1;
201 else
202 {
204 py = py + 2 * (dx1 - dy1);
205 }
207 }
208 }
209 }
210
212 t, float>> &image, std::tuple<float,float,float> color, int width, int height, int r
213 adius)
214 {
216 if (radius == 1) {
217 image[get_index(std::get<0>(p),std::get<1>(p),width)]=std::make_tuple(0.0f,
218 0.0f);
219 } else {
220 draw_filled_circle(std::get<0>(p),std::get<1>(p),radius,image,color,width,he
221 }
222 }
223 }
224
225 void draw_labels(std::vector<std::tuple<float, float, float>> &image, std::tuple<flo\
227 {
228 // These pixels are drawn in a graphics application and converted to 1's and 0's to\
229 render them here.
230
231 // 16_lable_10.png
232 // 60 29
233 // 870 657
234 char lable_10[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,\
235 0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,
236 0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
237 0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,
238 0,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,
239 1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
240 1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,0,0,0,0,
241 0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,
242 0,0,0,1,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,1,1,1,
243 0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,
244 0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,1,
245 1,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,
246 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,1,1,1,0,0,0,
247 0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,
248 1,1,0,0,0,0,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,
249 1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,
250 0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,1,
251 1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,
252 0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
253 0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
254 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,
255 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,
256 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,
257 0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,
258 0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,
259 1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,
260 0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
261 0,1,1,0,0,0,1,1,1,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,
262 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,
263 0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,
264 1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,
265 1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,
266 0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,
267 0,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,
268 0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,
269 1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,0,
270 0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,
271 0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,
272 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,
273 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
274 1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,
275 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0};
276 int xx=0; int yy=0;
277 for (int y=657;y<(657+29);++y)
278 {
279 for (int x=870;x<(870+60);x++) {
280 if (lable_10[get_index(xx,yy,60)] == 1) {
282 }
283 xx++;
284 }
285 yy++;
286 xx=0;
287 }
288
289 // 16_lable_15.png
290 // 80 39
291 // 691 576

292 char lable_15[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\
293 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
294 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,
295 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
296 0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,
297 1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
298 0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
299 0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
300 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,
301 0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,
302 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
303 1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,0,1,1,1,1,0,0,0,
304 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,
305 0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,
306 0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
307 1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
308 0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,
309 0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
310 0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,
311 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
312 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,
313 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,
314 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,
315 0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,
316 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,
317 0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
318 0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
319 0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,
320 0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
321 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
322 0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,
323 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,
324 1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,
325 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
326 0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,
327 0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
328 0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
329 0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
330 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
331 0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,
332 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
333 0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,0,
334 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
335 0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,0,0,
336 0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
337 0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,
338 0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
339 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,
340 0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,
341 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,
342 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,
343 0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,
344 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
345 0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,
346 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
347 1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
348 0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,
349 0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
350 1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,
351 1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
352 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,
353 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,
354 0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
355 1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,
356 0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
357 0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,
358 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,
359 0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,
360 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,
361 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
362 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,
363 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
364 0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
365 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
366 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0};
367 xx=0; yy=0;
368 for (int y=576;y<(576+39);++y)
369 {
370 for (int x=691;x<(691+80);x++) {
373 }
374 xx++;
375 }
376 yy++;
377 xx=0;
378 }
379
380 // 16_lable_30.png
381 // 101 49
382 // 473 459
383 char lable_30[]={0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\
384 0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
385 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,
386 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,
387 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
388 0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
389 1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,
390 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,
391 0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,
392 0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
393 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,
394 1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
395 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
396 0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,
397 0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,
398 0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,
399 0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,
400 0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
401 1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,
402 0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
403 1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,
404 0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,
405 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,
406 0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,
407 1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,
408 0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,
409 0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,
410 0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
411 1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,
412 0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
413 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,
414 1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
415 1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,
416 0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
417 0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,
418 0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,1,
419 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,
420 0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,
421 0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
422 0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
423 1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,
424 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
425 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,1,1,1,
426 1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
427 1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,
428 0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
429 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,
430 0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,
431 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,
432 0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,
433 1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
434 0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
435 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,
436 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
437 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
438 0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,
439 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,
440 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
441 0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,
442 0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,
443 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,
444 0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,
445 0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
446 0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
447 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
448 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,
449 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
450 0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
451 1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,
452 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,
453 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,
454 0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,
455 0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,
456 0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
457 0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
458 0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
459 0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,0,0,0,
460 0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,
461 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
462 0,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
463 0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,
464 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,
465 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,
466 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,
467 1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,
468 0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
469 0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,
470 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,
471 0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,
472 0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
473 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
474 1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
475 0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,
476 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,
477 1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,
478 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,
479 0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,
480 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
481 0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,1,1,1,1,1,1,0,
482 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
483 0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,
484 0,0,0,0,0,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
485 0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
486 1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,1,
487 1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,
488 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,
489 1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
490 1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
491 0,0,0,1,1,1,1,1,0,0,0,0,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,
492 0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,
493 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,
494 1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,
495 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
496 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
497 0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
498 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,
499 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,
500 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,
501 0,0};
502 xx=0; yy=0;
503 for (int y=459;y<(459+49);++y)
504 {
505 for (int x=473;x<(473+101);x++) {
508 }
509 xx++;
510 }
511 yy++;
512 xx=0;
513 }
514
515 // 16_lable_45.png
516 // 124 58
517 // 726 287
518 char lable_45[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\
519 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
520 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
521 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,
522 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,
523 0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
524 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
525 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,
526 0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
527 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
528 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
529 0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
530 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
531 0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
532 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
533 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
534 0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,
535 1,1,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
536 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
537 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
538 0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
539 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
540 1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,
541 0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
542 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
543 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,
544 0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
545 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
546 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,
547 0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
548 0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,
549 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
550 0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
551 0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,
552 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,
553 1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
554 1,1,1,1,1,1,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,
555 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,
556 1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
557 1,1,1,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,
558 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
559 0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
560 1,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
561 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,
562 0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,
563 0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
564 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,
565 0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,1,
566 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
567 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,
568 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,1,1,1,
569 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
570 0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,
571 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,
572 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
573 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,
574 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,0,
575 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
576 0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,0,0,0,
577 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,0,0,0,
578 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
579 0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,
580 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,
581 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
582 0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,
583 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,
584 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
585 0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
586 0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,
587 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,
588 0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
589 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
590 0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
591 0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
592 0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
593 0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
594 0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
595 0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
596 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
597 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
598 0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
599 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
600 0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
601 0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
602 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
603 0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
604 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
605 1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
606 0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
607 1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
608 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
609 0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,
610 0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
611 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
612 0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,
613 0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
614 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
615 0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,
616 0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
617 0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
618 1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,
619 0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
620 0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
621 1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
622 0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
623 0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,
624 0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,
625 0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
626 0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,
627 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
628 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
629 0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,1,
630 1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
631 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
632 1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,1,1,1,1,
633 1,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
634 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
635 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,0,
636 0,0,0,0,0,0,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
637 1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
638 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,0,0,0,0,
639 0,0,0,0,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
640 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,
641 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,
642 0,0,0,0,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
643 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,
644 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,
645 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
646 0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,
647 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
648 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,
649 0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,
650 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,
651 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
652 0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,
653 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
654 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
655 0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
656 0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,
657 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
658 0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
659 0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,
660 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
661 1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
662 0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,
663 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
664 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
665 1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,
666 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
667 1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
668 1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
669 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
670 1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
671 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,
672 0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,
673 1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,
674 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
675 0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,
676 1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
677 0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
678 0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,
679 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
680 0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
681 0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,
682 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
683 0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
684 0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,
685 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
686 0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
687 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,
688 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
689 0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0};
690 xx=0; yy=0;
691 for (int y=287;y<(287+58);++y)
692 {
693 for (int x=726;x<(726+124);x++) {
696 }
697 xx++;
698 }
699 yy++;
700 xx=0;
701 }
702
703 // 16_lable_jupiter.png
704 // 73 17
705 // 691 700
706 char lable_jupiter[]={0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1\
707 ,1,1,0,0,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0
708 ,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0
709 ,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0
710 ,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0
711 ,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1
712 ,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1
713 ,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1
714 ,1,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0
715 ,0,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0
716 ,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,1
717 ,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1
718 ,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0
719 ,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1
720 ,1,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0
721 ,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0
722 ,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,1
723 ,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1
724 ,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0
725 ,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1
726 ,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0
727 ,0,1,1,1,0,1,1,1,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0
728 ,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,1,1,1,0,0,0
729 ,1,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1
730 ,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,1,1,1,1,0,0,1,1,1,1,0,0,1,1,1,1,0
731 ,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1
732 ,1,1,0,0,1,1,1,0,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1
733 ,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,0,1
734 ,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1
735 ,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,0,1,1,1,0};
736 xx=0; yy=0;
737 for (int y=700;y<(700+17);++y)
738 {
739 for (int x=691;x<(691+73);x++) {
740 if (lable_jupiter[get_index(xx,yy,73)] == 1) {
742 }
743 xx++;
744 }
745 yy++;
746 xx=0;
747 }
748
749 // 16_lable_market_size.png
750 // 357 53
751 // 1112 68
752 char lable_market_size[]={0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0\
753 ,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
754 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
755 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
756 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
757 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
758 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
759 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
760 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
761 ,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
762 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
763 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
764 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1
765 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
766 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
767 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1
768 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
769 ,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1
770 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1
771 ,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
772 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1
773 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
774 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
775 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0
776 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
777 ,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1
778 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
779 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
780 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1
781 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1
782 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
783 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1
784 ,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1
785 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
786 ,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
787 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1
788 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
789 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1
790 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
791 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
792 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
793 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
794 ,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1
795 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0
796 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
797 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1
798 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1
799 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
800 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1
801 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1
802 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
803 ,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
804 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1
805 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
806 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1
807 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
808 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
809 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
810 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
811 ,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
812 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0
813 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
814 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
815 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
816 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
817 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1
818 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1
819 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
820 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1
821 ,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
822 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1
823 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1
824 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
825 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
826 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
827 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
828 ,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
829 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
830 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
831 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
832 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
833 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
834 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0
835 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
836 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
837 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
838 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
839 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
840 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1
841 ,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
842 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
843 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
844 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
845 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
846 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
847 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
848 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
849 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
850 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
851 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
852 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
853 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
854 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
855 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
856 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
857 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1
858 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
859 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
860 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
861 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
862 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
863 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
864 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
865 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
866 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
867 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
868 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
869 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
870 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
871 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
872 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
873 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
874 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1
875 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
876 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
877 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
878 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
879 ,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
880 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
881 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
882 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
883 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
884 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
885 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
886 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
887 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
888 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
889 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
890 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
891 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1
892 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
893 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
894 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
895 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
896 ,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
897 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
898 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
899 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
900 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
901 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
902 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
903 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
904 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
905 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
906 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
907 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
908 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1
909 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
910 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
911 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
912 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1
913 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
914 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
915 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
916 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
917 ,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
918 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
919 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
920 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
921 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
922 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
923 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
924 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
925 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1
926 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
927 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
928 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
929 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0
930 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
931 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
932 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
933 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
934 ,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
935 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
936 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1
937 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
938 ,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
939 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
940 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
941 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
942 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1
943 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
944 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
945 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0
946 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
947 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1
948 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
949 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
950 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1
951 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
952 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
953 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1
954 ,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
955 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
956 ,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
957 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
958 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
959 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
960 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
961 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
962 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
963 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
964 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1
965 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
966 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
967 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1
968 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
969 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
970 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1
971 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
972 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
973 ,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
974 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
975 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
976 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
977 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
978 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
979 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
980 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0
981 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1
982 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
983 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
984 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1
985 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
986 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
987 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1
988 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
989 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
990 ,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
991 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
992 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
993 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
994 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
995 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
996 ,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
997 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
998 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1
999 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1000 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1001 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1
1002 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1003 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1004 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1
1005 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1006 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1007 ,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1008 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1009 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1010 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1011 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
1012 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1013 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1014 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
1015 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1
1016 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1017 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1018 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1019 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1020 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1021 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1022 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1023 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1024 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1025 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1026 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1027 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1
1028 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1029 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1030 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1031 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1032 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1033 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1034 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1035 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1036 ,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1037 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1038 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1039 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1040 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1041 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1042 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1043 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1044 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1
1045 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1046 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1047 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1048 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1049 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1050 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1051 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1052 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1053 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1054 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1055 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1056 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1057 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1058 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1059 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1060 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1061 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1
1062 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1063 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1064 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1065 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1066 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1067 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1068 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1069 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1070 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1071 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1072 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1073 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1074 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1075 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1076 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1077 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1078 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1
1079 ,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1080 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1081 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1082 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1083 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1084 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1085 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1086 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1087 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1088 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1089 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1090 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1091 ,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1092 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1093 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1094 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1095 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1
1096 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1097 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1098 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1099 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0
1100 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1101 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1102 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1103 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1104 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1105 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1106 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1107 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1108 ,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1109 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1110 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1111 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1112 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1
1113 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1114 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1115 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1116 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
1117 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1118 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1119 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1120 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1121 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1122 ,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1123 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1124 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1125 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1126 ,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1127 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1128 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1129 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1
1130 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1131 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1132 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1133 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
1134 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1135 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1136 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1137 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1138 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1
1139 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1140 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1141 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1
1142 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1143 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1144 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1145 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1146 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1
1147 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1148 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1149 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1150 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1151 ,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1152 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1153 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1154 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1155 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1
1156 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1157 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1
1158 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1
1159 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1160 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1161 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1162 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1163 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1
1164 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1165 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1166 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1167 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1168 ,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1169 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1170 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1171 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1172 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1
1173 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1174 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1
1175 ,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1
1176 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1177 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1178 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1179 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1180 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1
1181 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1182 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1183 ,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1184 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1185 ,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1186 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1187 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1188 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1189 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1
1190 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1191 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1
1192 ,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1
1193 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1194 ,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1195 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1196 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1197 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1198 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1199 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1200 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0
1201 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1202 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1203 xx=0; yy=0;
1204 for (int y=68;y<(68+53);++y)
1205 {
1206 for (int x=1112;x<(1112+357);x++) {
1207 if (lable_market_size[get_index(xx,yy,357)] == 1) {
1209 }
1210 xx++;
1211 }
1212 yy++;
1213 xx=0;
1214 }
1215
1216 // 16_lable_mars.png
1217 // 53 18
1218 // 1163 700
1219 char lable_mars[]={0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,\
1220 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,
1221 1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1222 1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,
1223 1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,
1224 0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,
1225 0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,
1226 1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,1,1,
1227 1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,
1228 0,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,
1229 1,1,0,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,
1230 1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,
1231 0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,
1232 1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,0,1,1,1,1,0,0,0,0,0,0,0,
1233 0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,
1234 0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,
1235 1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,
1236 1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,
1237 0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,
1238 1,0,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,
1239 0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,
1240 0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,0,0,0,0,
1241 1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1,0};
1242 xx=0; yy=0;
1243 for (int y=700;y<(700+18);++y)
1244 {
1245 for (int x=1163;x<(1163+53);x++) {
1246 if (lable_mars[get_index(xx,yy,53)] == 1) {
1248 }
1249 xx++;
1250 }
1251 yy++;
1252 xx=0;
1253 }
1254
1255 // 16_lable_mercury.png
1256 // 88 17
1257 // 462 700
1258 char lable_mercury[]={0,1,1,1,1,1,1,0,0,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,0,0,0,1,1\
1259 ,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1
1260 ,1,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0
1261 ,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1
1262 ,1,1,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,1,1,1,1,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,1
1263 ,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0
1264 ,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0
1265 ,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,1,1,1,1,0,0,0,1
1266 ,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1
1267 ,1,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,1,1,1,1
1268 ,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,1,1,1,0,0,1,1,1,1,0,0,1,1,1,1,0
1269 ,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0
1270 ,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,1,1,1,0,0,1,1,1,1,0,0,1
1271 ,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0
1272 ,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,1,1,1,0,0,1,1,1
1273 ,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,1,1,1,1
1274 ,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,0,0
1275 ,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0
1276 ,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1
1277 ,1,1,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1
1278 ,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0
1279 ,0,1,1,1,1,1,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0
1280 ,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1
1281 ,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0
1282 ,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0
1283 ,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0
1284 ,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1
1285 ,1,1,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1
1286 ,1,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1
1287 ,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0
1288 ,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0
1289 ,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0,0
1290 ,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,1
1291 ,1,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,1,1,1
1292 ,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0
1293 ,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0};
1294 xx=0; yy=0;
1295 for (int y=700;y<(700+17);++y)
1296 {
1297 for (int x=462;x<(462+88);x++) {
1298 if (lable_mercury[get_index(xx,yy,88)] == 1) {
1300 }
1301 xx++;
1302 }
1303 yy++;
1304 xx=0;
1305 }
1306
1307 // 16_lable_venus.png
1308 // 58 17
1309 // 1158 345
1310 char lable_venus[]={1,1,1,0,0,0,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1\
1311 ,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,1,1,1
1312 ,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0
1313 ,0,1,1,1,0,0,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0
1314 ,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1
1315 ,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,1,1,1,0,0,0,1,1,1
1316 ,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0
1317 ,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0
1318 ,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0
1319 ,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1
1320 ,1,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0
1321 ,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0
1322 ,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,1,0,1,1,1,0,0,0,0,1
1323 ,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1
1324 ,1,1,0,0,1,1,1,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0
1325 ,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1
1326 ,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,1
1327 ,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1
1328 ,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0
1329 ,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1
1330 ,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0
1331 ,0,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1
1332 ,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,1,1,1,0
1333 ,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0};
1334 xx=0; yy=0;
1335 for (int y=345;y<(345+17);++y)
1336 {
1337 for (int x=1158;x<(1158+58);x++) {
1338 if (lable_venus[get_index(xx,yy,58)] == 1) {
1340 }
1341 xx++;
1342 }
1343 yy++;
1344 xx=0;
1345 }
1346 }
1347
1348 void draw_label_lines(std::vector<std::tuple<float, float, float>> &image, std::tupl\
1349 e<float,float,float> &color, int width, int height, int radius)
1350 {
1354 get_line_points(points,coords);
1355 draw(points,image,color,width,height,radius);
1356 points.clear();
1369 }
1370
1371 void draw_hexagon(std::vector<std::tuple<float, float, float>> &image, std::tuple<fl\
1372 oat,float,float> &color, int centerx, int centery, int radius, int width, int height
1373 , int cradius)
1374 {
1376 float ux = centerx - radius;
1377 float uy = centery - radius;
1378 float pt1x=ux, pt1y=uy, pt2x=ux, pt2y=uy, pt3x=ux, pt3y=uy, pt4x=ux, pt4y=uy, pt5x=\
1379 ux, pt5y=uy, pt6x=ux, pt6y=uy;
1380
1381 float const PI = 3.14159265;
1382 float A, B, C;
1383 A = radius/2;
1384 C = A / sin(30*PI/180);
1385 B = C * cos(30*PI/180);
1386
1387 pt1x += 0; pt1y += B;
1388 pt2x += A; pt2y += 0;
1389 pt3x += A+C; pt3y += 0;
1390 pt4x += 2*C; pt4y += B;
1391 pt5x += A+C; pt5y += 2*B;
1392 pt6x += A; pt6y += 2*B;
1393
1395 coords=std::make_tuple(pt1x,pt1y,pt2x,pt2y);
1397 draw(points,image,color,width,height,cradius);
1419 }
1420
1421 void generate_noise_image(std::vector<std::tuple<float, float, float>> &image, int w\
1423 {
1425 float rndnum=0.0f;
1426
1428 std::mt19937 mt(rd());
1429 std::uniform_real_distribution<float> dist(0.0f, 1.0f);
1430
1433 rndnum=dist(mt);
1434 color=std::make_tuple(rndnum,rndnum,rndnum);
1436 }
1437 }
1438 }
1439
1440 void generate_linear_gradient_image(std::vector<std::tuple<float, float, float>> &im\
1441 age, std::tuple<float, float, float> &fcolor, std::tuple<float, float, float> &tcolo
1442 r, int width, int height)
1443 {
1445 double resultRed=0.0f;
1446 double resultGreen=0.0f;
1447 double resultBlue=0.0f;
1448 double fr,fg,fb,tr,tg,tb;
1449 double percent=0.0f;
1450 std::tie(fr,fg,fb)=fcolor;
1451 std::tie(tr,tg,tb)=tcolor;
1452
1454 percent=double(y)/double(height);
1455 resultRed = fr + percent * (tr - fr);
1456 resultGreen = fg + percent * (tg - fg);
1457 resultBlue = fb + percent * (tb - fb);
1458 color=std::make_tuple(resultRed,resultGreen,resultBlue);
1461 }
1462 }
1463 }
1464
1467 {
1471
1480 }
1481 }
1482 }
1483
1484 void blend_hexagon(std::vector<std::tuple<float, float, float>> &blend1,std::vector<\
1485 std::tuple<float, float, float>> &blend2,int width,int height)
1486 {
1489 float r=0.0f; float g=0.0f; float b=0.0f; float alpha=0.8f;
1490
1493 if (blend2[get_index(x,y,width)] == color2)
1494 {
1496 r = (std::get<0>(color1) * alpha) + (0.0f * (1.0f - alpha));
1497 g = (std::get<1>(color1) * alpha) + (0.0f * (1.0f - alpha));
1498 b = (std::get<2>(color1) * alpha) + (0.0f * (1.0f - alpha));
1499 blend1[get_index(x,y,width)]=std::make_tuple(r,g,b);
1500 }
1501 }
1502 }
1503 }
1504
1505 double distance(int x1, int y1, int x2, int y2)
1506 {
1507 return sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2) * 1.0);
1508 }
1509
1510 void generate_radial_gradient_image(std::vector<std::tuple<float, float, float>> &im\
1513 {
1515 std::tuple<float, float, float> pink=std::tuple(1.0f,0.0f,1.0f);
1516 std::vector<std::tuple<float, float, float>> mask;
1517 mask.resize(calc_size(width,height));
1518 double distanceFromCenter=0.0f;
1522
1524 {
1525 for (int x=0;x<width;++x)
1526 {
1527 mask[get_index(x,y,width)]=pink;
1528 image[get_index(x,y,width)]=fcolor;
1529 }
1530 }
1531
1532 int x0 = 0;
1533 int y0 = (height/2);
1534 int d = 3 - 2 * (height/2);
1535 int xx=(width/2)-1;
1536 int yy=(height/2)-1;
1537

1539 {
1541 //if (((sx>=0)&&(sx<width)) && ((ex>=0)&&(ex<width)) && ((ny>=0)&&(ny<height))) {
1542 for (int i = sx; i <= ex; i++) {
1543 mask[get_index(i, ny, width)]=fcolor;
1544 }
1545 //}
1546 };
1547
1548 while (y0 >= x0)
1549 {
1550 drawline(xx - x0, yy + x0, xx - y0);
1551 drawline(xx - y0, yy + y0, xx - x0);
1552 drawline(xx - x0, yy + x0, xx + y0);
1553 drawline(xx - y0, yy + y0, xx + x0);
1554 if (d < 0) d += 4 * x0++ + 6;
1555 else d += 4 * (x0++ - y0--) + 10;
1556 }
1557
1559 {
1561 {
1562 if (mask[get_index(x,y,width)] != pink) {
1563 distanceFromCenter = (distance(x, y, width/2, height/2)/(height/2));
1564 resultRed = std::get<0>(fcolor) + distanceFromCenter * (std::get<0>(
1565 d::get<0>(fcolor));
1566 resultGreen = std::get<1>(fcolor) + distanceFromCenter * (std::get<1
1567 std::get<1>(fcolor));
1568 resultBlue = std::get<2>(fcolor) + distanceFromCenter * (std::get<2>
1569 td::get<2>(fcolor));
1570 color=std::tuple(resultRed,resultGreen,resultBlue);
1572 } else {
1573 image[get_index(x,y,width)]=tcolor;
1574 }
1575 }
1576 }
1577 }
1578
1579 void generate_repeating_texture_image(std::vector<std::tuple<float, float, float>> &\
1580 image, std::tuple<float, float, float> &color, int width, int height)
1581 {
1582 std::tuple<float, float, float> bgcolor=std::make_tuple(1.0f,0.0f,1.0f);
1583 // 0,0 0,22 18,32 36,22 54,32 54,54 36,64 18,54 18,32 36,0 36,22 72,0 72,22 54,32 7\
1584 2,64 54,54 0,64 18,54
1587 image[get_index(x,y,width)]=bgcolor;
1588 }
1589 }
1590
1591 int arr[13][2] = {{0,0},{0,22},{18,32},{36,22},{54,32},{54,54},{36,64},{18,54},{36,\
1592 0},{72,0},{72,22},{72,64},{0,64}};
1593 int arr2[13][2] = {{0,1},{1,2},{2,3},{3,4},{4,5},{5,6},{6,7},{7,2},{8,3},{9,10},{10\
1594 ,4},{11,5},{12,7}};
1596
1597 for (int i=0;i<13;++i) {
1598 coords=std::make_tuple(int(arr[arr2[i][0]][0]), int(arr[arr2[i][0]][1]), int(arr[a\
1599 rr2[i][1]][0]), int(arr[arr2[i][1]][1]));
1601 }
1602 }
1603
1604 void render_repeating_texture_image(std::vector<std::tuple<float, float, float>> &te\
1605 xture, int tw, int th,std::vector<std::tuple<float, float, float>> &image, int iw, i
1606 nt ih)
1607 {
1608 for (int y=0;y<ih;++y) {
1609 for (int x=0;x<iw;++x) {
1610 image[get_index(x,y,iw)]=texture[get_index(x%(tw-1),y%(th-1),tw)];
1611 }
1612 }
1613 }
1614
1615 void do_cookie_cut(std::vector<std::tuple<float, float, float>> &image, int w, int h\
1616 , std::vector<std::tuple<float, float, float>> &cookie, int cw, int ch, int startx,
1617 int starty)
1618 {
1619 int cx=0;int cy=0;
1620 for (int y=starty;y<(starty+ch);++y) {
1621 for (int x=startx;x<(startx+cw);++x) {
1622 cookie[get_index(cx,cy,cw)]=image[get_index(x,y,w)];
1623 cx++;
1624 }
1625 cy++;
1626 cx=0;
1627 }
1628 }
1629
1630 void add_honeycomb(std::vector<std::tuple<float, float, float>> &image, std::vector<\
1631 std::tuple<float, float, float>> &alpha, std::vector<std::tuple<float, float, float>
1632 > &texture, int w, int h)
1633 {
1634 std::tuple<float, float, float> color1;
1637 std::tuple<float, float, float> pink=std::make_tuple(1.0f,0.0f,1.0f);
1638 float ir,ig,ib;
1639
1640 for (int y=0;y<h;++y) {
1641 for (int x=0;x<w;++x) {
1642 if (texture[get_index(x,y,w)] != pink) {
1643 color1=image[get_index(x,y,w)];
1644 color2=texture[get_index(x,y,w)];
1645 color3=alpha[get_index(x,y,w)];
1646 ir = ((std::get<0>(color2) * std::get<0>(color3)) + (std::get<0>(col
1647 - std::get<0>(color3))));
1648 ig = ((std::get<1>(color2) * std::get<0>(color3)) + (std::get<1>(col
1649 - std::get<0>(color3))));
1650 ib = ((std::get<2>(color2) * std::get<0>(color3)) + (std::get<2>(col
1651 - std::get<0>(color3))));
1652 image[get_index(x,y,w)]=std::make_tuple(ir,ig,ib);
1653 }
1654 }
1655 }
1656 }
1657
1658 void add_white_heaxagon_border(std::vector<std::tuple<float, float, float>> &image1,\
1659 std::vector<std::tuple<float, float, float>> &image2,int width,int height)
1660 {
1662
1665 if (image2[get_index(x,y,width)] == color)
1666 {
1667 image1[get_index(x,y,width)]=color;
1668 }
1669 }
1670 }
1671 }
1672
1673 void stamp_cookie(std::vector<std::tuple<float, float, float>> &image, int w, int h,\
1674 std::vector<std::tuple<float, float, float>> &cookie, int cw, int ch, int startx, i
1675 nt starty)
1676 {
1680 image[get_index(x,y,w)]=cookie[get_index(cx,cy,cw)];
1681 cx++;
1682 }
1683 cy++;
1684 cx=0;
1685 }
1686 }
1687
1690 {
1694 dl;
1695
1697 {
1698 color=image[i];
1700 std::get<2>(color)*255.0f);
1701 }
1702 out.close();
1703 }
1704
1705 int main()
1706 {
1709
1710 image1.resize(calc_size(width,height));
1711
1712 generate_noise_image(image1, width, height);
1713
1714 std::cout << "saving: 16_draw_market_size1.ppm." << std::endl;
1715 save_image(image1,width,height,"16_draw_market_size1.ppm");
1716
1719
1720 std::tuple<float, float, float> fcolor=std::make_tuple(0.5294117647f,0.8235294118f,\
1721 0.8078431373f);
1722 std::tuple<float, float, float> tcolor=std::make_tuple(0.2588235294f,0.2196078431f,\
1723 0.3921568627f);
1724 generate_linear_gradient_image(image2,fcolor,tcolor,width,height);
1725
1728
1730
1733
1734 // radial gradient
1736 image3.resize(calc_size(900,900));
1737
1738 fcolor=std::make_tuple(1.0f,1.0f,1.0f);
1739 tcolor=std::make_tuple(0.0f,0.0f,0.0f);
1740
1741 generate_radial_gradient_image(image3,fcolor,tcolor,900,900);
1742
1744 save_image(image3,900,900,"16_draw_market_size4.ppm");
1745
1746 // Repeating texture generation
1749
1751 generate_repeating_texture_image(image4,fcolor,73,65);
1752

1755
1756 // Render repeating texture
1759
1760 render_repeating_texture_image(image4,73,65,image5,900,900);
1761
1764
1765 // Do cookie cut
1768
1769 do_cookie_cut(image1,width,height,image6,900,900,350,0);
1770
1773
1774 // Add honeycomb
1775 add_honeycomb(image6,image3,image5,900,900);
1776
1779
1780 // Stamp cookie
1781 stamp_cookie(image1,width,height,image6,900,900,350,0);
1782
1785
1786 // Hexagons
1791 draw_hexagon(image7,fcolor,784,340,190,width,height,2);
1795
1796 flood_fill(image7,784,340,tcolor,fcolor,width);
1800
1803
1811
1814
1815 blend_hexagon(image1,image7,width,height);
1816
1819
1820 add_white_heaxagon_border(image1,image8,width,height);
1821
1824
1825 // Add label lines
1827 draw_label_lines(image1,fcolor,width,height,2);
1828
1831
1832 // Add labels
1833 draw_labels(image1,fcolor,width,height);
1834
1837
1838 return 0;
1839 }
16_draw_investment.cpp - 94001 bytes.
1 // Compile: clang++ -std=c++17 16_draw_investment.cpp -o 16_draw_investment

3
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
11
13 {
15 }
16
18 {
20 }
21
22 void clear_image(std::vector<std::tuple<float, float, float>> &image, std::tuple<fl\
23 oat, float, float> &color, int width, int height)
24 {
28 }
29 }
30 }
31
34 {
35 int x0 = 0;
36 int y0 = radius;
37 int d = 3 - 2 * radius;
39

41 {
43 // if (((sx>=0)&&(sx<width)) && ((ex>=0)&&(ex<width)) && ((ny>=0)&&(ny<height))) {
44 for (int i = sx; i <= ex; i++) {
46 }
47 //}
48 };
49
50 while (y0 >= x0)
51 {
52 drawline(x - x0, x + x0, y - y0);
53 drawline(x - y0, x + y0, y - x0);
54 drawline(x - x0, x + x0, y + y0);
55 drawline(x - y0, x + y0, y + x0);
56 if (d < 0) d += 4 * x0++ + 6;
57 else d += 4 * (x0++ - y0--) + 10;
58 }
59 }
60
62 {
65 }
66
69 }
70
72 > &coords)
73 {
75 dx = x2 - x1; dy = y2 - y1;
76 if (dx == 0)
77 {
78 if (y2 < y1) std::swap(y1, y2);
79 for (y = y1; y <= y2; y++)
81 return;
82 }
83 if (dy == 0)
84 {
85 if (x2 < x1) std::swap(x1, x2);
86 for (x = x1; x <= x2; x++)
88 return;
89 }
91 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
92 if (dy1 <= dx1)
93 {
94 if (dx >= 0)
95 {
96 x = x1; y = y1; xe = x2;
97 }
98 else
99 {
100 x = x2; y = y2; xe = x1;
101 }
103 for (i = 0; x<xe; i++)
104 {
105 x = x + 1;
106 if (px<0)
107 px = px + 2 * dy1;
108 else
109 {
111 px = px + 2 * (dy1 - dx1);
112 }
114 }
115 }
116 else
117 {
118 if (dy >= 0)
119 {
120 x = x1; y = y1; ye = y2;
121 }
122 else
123 {
124 x = x2; y = y2; ye = y1;
125 }
127 for (i = 0; y<ye; i++)
128 {
129 y = y + 1;
130 if (py <= 0)
131 py = py + 2 * dx1;
132 else
133 {
135 py = py + 2 * (dx1 - dy1);
136 }
138 }
139 }
140 }
141
145 {
147
152 do
153 {
155 ang+=0.001;
158 }
160
163
166
171
173 {
177 }
178 }
181 xs.clear();
182 }
183
185 {
186 for (int i = sx; i <= ex; i++)
188 };
189
192 }
193 }
194
197 {
201 dx = x2 - x1; dy = y2 - y1;
202
203 if (dx == 0)
204 {
205 if (y2 < y1) std::swap(y1, y2);
206 for (y = y1; y <= y2; y++)
208 return;
209 }
210 if (dy == 0)
211 {
212 if (x2 < x1) std::swap(x1, x2);

213 for (x = x1; x <= x2; x++)
215 return;
216 }
218 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
219 if (dy1 <= dx1)
220 {
221 if (dx >= 0)
222 {
223 x = x1; y = y1; xe = x2;
224 }
225 else
226 {
227 x = x2; y = y2; xe = x1;
228 }
230 for (i = 0; x<xe; i++)
231 {
232 x = x + 1;
233 if (px<0)
234 px = px + 2 * dy1;
235 else
236 {
238 px = px + 2 * (dy1 - dx1);
239 }
241 }
242 }
243 else
244 {
245 if (dy >= 0)
246 {
247 x = x1; y = y1; ye = y2;
248 }
249 else
250 {
251 x = x2; y = y2; ye = y1;
252 }
254 for (i = 0; y<ye; i++)
255 {
256 y = y + 1;
257 if (py <= 0)
258 py = py + 2 * dx1;
259 else
260 {
262 py = py + 2 * (dx1 - dy1);
263 }
265 }
266 }
267 }
268
271 {
274
276 std::mt19937 mt(rd());
278
281 rndnum=dist(mt);
284 }
285 }
286 }
287
291 {
300
309 }
310 }
311 }
312
315 {
319
328 }
329 }
330 }
331
332 double distance(int x1, int y1, int x2, int y2)
333 {
334 return sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2) * 1.0);
335 }
336
337 void generate_radial_gradient_image(std::vector<std::tuple<float, float, float>> &im\
340 {

342 std::tuple<float, float, float> pink=std::tuple(1.0f,0.0f,1.0f);
343 std::vector<std::tuple<float, float, float>> mask;
344 mask.resize(calc_size(width,height));
345 double distanceFromCenter=0.0f;
349
351 {
353 {
354 mask[get_index(x,y,width)]=pink;
355 image[get_index(x,y,width)]=fcolor;
356 }
357 }
358
359 int x0 = 0;
360 int y0 = (height/2);
361 int d = 3 - 2 * (height/2);
362 int xx=(width/2)-1;
363 int yy=(height/2)-1;
364
366 {
368 //if (((sx >= 0)&&(sx < width)) && ((ex >= 0)&&(ex < width)) && ((ny >= 0)&&(ny < \
369 height))) {
370 for (int i = sx; i <= ex; i++) {
371 mask[get_index(i, ny, width)]=fcolor;
372 }
373 //}
374 };
375
376 while (y0 >= x0)
377 {
378 drawline(xx - x0, yy + x0, xx - y0);
379 drawline(xx - y0, yy + y0, xx - x0);
380 drawline(xx - x0, yy + x0, xx + y0);
381 drawline(xx - y0, yy + y0, xx + x0);
382 if (d < 0) d += 4 * x0++ + 6;
383 else d += 4 * (x0++ - y0--) + 10;
384 }
385
387 {
389 {
390 if (mask[get_index(x,y,width)] != pink) {
391 distanceFromCenter = (distance(x, y, width/2, height/2)/(height/2));
392 resultRed = std::get<0>(fcolor) + distanceFromCenter * (std::get<0>(
393 d::get<0>(fcolor));
394 resultGreen = std::get<1>(fcolor) + distanceFromCenter * (std::get<1
395 std::get<1>(fcolor));
396 resultBlue = std::get<2>(fcolor) + distanceFromCenter * (std::get<2>
397 td::get<2>(fcolor));
398 color=std::tuple(resultRed,resultGreen,resultBlue);
400 } else {
401 image[get_index(x,y,width)]=tcolor;
402 }
403 }
404 }
405 }
406
407 void generate_repeating_texture_image(std::vector<std::tuple<float, float, float>> &\
408 image, std::tuple<float, float, float> &color, int width, int height)
409 {
410 std::tuple<float, float, float> bgcolor=std::make_tuple(1.0f,0.0f,1.0f);
411 // 0,0 0,22 18,32 36,22 54,32 54,54 36,64 18,54 18,32 36,0 36,22 72,0 72,22 54,32 7\
412 2,64 54,54 0,64 18,54
415 image[get_index(x,y,width)]=bgcolor;
416 }
417 }
418
419 int arr[13][2] = {{0,0},{0,22},{18,32},{36,22},{54,32},{54,54},{36,64},{18,54},{36,\
420 0},{72,0},{72,22},{72,64},{0,64}};
421 int arr2[13][2] = {{0,1},{1,2},{2,3},{3,4},{4,5},{5,6},{6,7},{7,2},{8,3},{9,10},{10\
422 ,4},{11,5},{12,7}};
424
425 for (int i=0;i<13;++i) {
426 coords=std::make_tuple(int(arr[arr2[i][0]][0]), int(arr[arr2[i][0]][1]), int(arr[a\
427 rr2[i][1]][0]), int(arr[arr2[i][1]][1]));

429 }
430 }
431
432 void render_repeating_texture_image(std::vector<std::tuple<float, float, float>> &te\
433 xture, int tw, int th,std::vector<std::tuple<float, float, float>> &image, int iw, i
434 nt ih)
435 {
436 for (int y=0;y<ih;++y) {
437 for (int x=0;x<iw;++x) {
438 image[get_index(x,y,iw)]=texture[get_index(x%(tw-1),y%(th-1),tw)];
439 }
440 }
441 }
442
443 void do_cookie_cut(std::vector<std::tuple<float, float, float>> &image, int w, int h\
444 , std::vector<std::tuple<float, float, float>> &cookie, int cw, int ch, int startx,
445 int starty)
446 {
450 cookie[get_index(cx,cy,cw)]=image[get_index(x,y,w)];
451 cx++;
452 }
453 cy++;
454 cx=0;
455 }
456 }
457
458 void add_honeycomb(std::vector<std::tuple<float, float, float>> &image, std::vector<\
459 std::tuple<float, float, float>> &alpha, std::vector<std::tuple<float, float, float>
460 > &texture, int w, int h)
461 {
465 std::tuple<float, float, float> pink=std::make_tuple(1.0f,0.0f,1.0f);
466 float ir,ig,ib;
467
468 for (int y=0;y<h;++y) {
469 for (int x=0;x<w;++x) {
470 if (texture[get_index(x,y,w)] != pink) {

471 color1=image[get_index(x,y,w)];
472 color2=texture[get_index(x,y,w)];
473 color3=alpha[get_index(x,y,w)];
474 ir = ((std::get<0>(color2) * std::get<0>(color3)) + (std::get<0>(col
475 - std::get<0>(color3))));
476 ig = ((std::get<1>(color2) * std::get<0>(color3)) + (std::get<1>(col
477 - std::get<0>(color3))));
478 ib = ((std::get<2>(color2) * std::get<0>(color3)) + (std::get<2>(col
479 - std::get<0>(color3))));
480 image[get_index(x,y,w)]=std::make_tuple(ir,ig,ib);
481 }
482 }
483 }
484 }
485
486 void stamp_cookie(std::vector<std::tuple<float, float, float>> &image, int w, int h,\
487 std::vector<std::tuple<float, float, float>> &cookie, int cw, int ch, int startx, i
488 nt starty)
489 {
493 image[get_index(x,y,w)]=cookie[get_index(cx,cy,cw)];
494 cx++;
495 }
496 cy++;
497 cx=0;
498 }
499 }
500
501 void draw_labels(std::vector<std::tuple<float, float, float>> &image, std::tuple<flo\
503 {
504 // 16_lable_investment_10.png
505 // 79 38
506 // 1198 577
507 char lable_investment_10[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\
508 ,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0
509 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
510 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
511 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
512 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
513 ,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0
514 ,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
515 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0
516 ,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
517 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1
518 ,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,0
519 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0
520 ,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0
521 ,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1
522 ,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
523 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0
524 ,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0
525 ,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0
526 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0
527 ,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0
528 ,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
529 ,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0
530 ,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0
531 ,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
532 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0
533 ,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0
534 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1
535 ,0,0,0,1,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0
536 ,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
537 ,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
538 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0
539 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
540 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0
541 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0
542 ,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0
543 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0
544 ,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
545 ,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
546 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
547 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0
548 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
549 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0
550 ,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0
551 ,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
552 ,0,0,0,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0
553 ,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
554 ,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
555 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1
556 ,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0
557 ,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0,0,0,0
558 ,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0
559 ,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1
560 ,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1
561 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0
562 ,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0
563 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1
564 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0
565 ,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0
566 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
567 ,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0
568 ,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0
569 ,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0
570 ,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0
571 ,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
572 ,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0
573 ,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
574 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1
575 ,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
576 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0
577 ,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0
578 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0};
579 int xx=0; int yy=0;
580 for (int y=577;y<(577+38);++y)
581 {
582 for (int x=1198;x<(1198+79);x++) {
583 if (lable_investment_10[get_index(xx,yy,79)] == 1) {
585 }
586 xx++;
587 }
588 yy++;
589 xx=0;
590 }
591
593 // 80 38
594 // 338 615
596 ,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0
597 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
598 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
599 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1
600 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
601 ,0,0,0,0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,1,1,1
602 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
603 ,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0
604 ,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0
605 ,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0
606 ,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0
607 ,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0
608 ,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0
609 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,0
610 ,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1
611 ,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0
612 ,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0
613 ,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1
614 ,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0
615 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0
616 ,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1
617 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1
618 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0
619 ,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0,0,0,0
620 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0
621 ,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0
622 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
623 ,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
624 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
625 ,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
626 ,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0
627 ,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
628 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0
629 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
630 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
631 ,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0
632 ,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
633 ,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0
634 ,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
635 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
636 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0
637 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0
638 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1
639 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0
640 ,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1
641 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0
642 ,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0
643 ,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1
644 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0
645 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0
646 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,1
647 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0
648 ,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0
649 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0
650 ,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0
651 ,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
652 ,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
653 ,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0
654 ,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
655 ,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0
656 ,1,1,0,0,0,0,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
657 ,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0
658 ,0,0,0,0,0,0,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0
659 ,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0
660 ,0,0,1,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0
661 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1
662 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1
663 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,0,1,1,1,1
664 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
665 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1
666 ,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
667 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0};
668 xx=0; yy=0;
669 for (int y=615;y<(615+38);++y)
670 {
671 for (int x=338;x<(338+80);x++) {
674 }
675 xx++;
676 }
677 yy++;
678 xx=0;
679 }
680
682 // 81 38
683 // 1196 345
685 ,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0
686 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
687 ,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0
688 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
689 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
690 ,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0
691 ,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
692 ,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0
693 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
694 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1
695 ,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1
696 ,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0
697 ,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0
698 ,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0
699 ,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0
700 ,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0
701 ,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
702 ,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1
703 ,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
704 ,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0
705 ,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
706 ,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0
707 ,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0
708 ,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1
709 ,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0
710 ,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0
711 ,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1
712 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1
713 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1
714 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,1,1,0,0,0
715 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0
716 ,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0
717 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0
718 ,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0
719 ,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0
720 ,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
721 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
722 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
723 ,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
724 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
725 ,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0
726 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
727 ,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0
728 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
729 ,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0
730 ,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
731 ,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0
732 ,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
733 ,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
734 ,0,0,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0
735 ,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
736 ,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0
737 ,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0
738 ,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0
739 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1
740 ,1,0,0,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1
741 ,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,0,0
742 ,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0
743 ,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0
744 ,0,0,0,1,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0
745 ,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0
746 ,1,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0
747 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0
748 ,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1
749 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,0,0,0,0,1
750 ,1,1,1,1,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,1,1,1,1,1,0,0
751 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1
752 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
753 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1
754 ,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
755 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0
756 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
757 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0};
758 xx=0; yy=0;
759 for (int y=345;y<(345+38);++y)
760 {
761 for (int x=1196;x<(1196+81);x++) {
764 }
765 xx++;
766 }
767 yy++;
768 xx=0;
769 }
770
772 // 81 38
773 // 337 430
775 ,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0
776 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0
777 ,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0
778 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
779 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0
780 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0
781 ,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
782 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0
783 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
784 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1
785 ,1,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0
786 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1
787 ,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0
788 ,0,0,0,1,1,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0
789 ,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
790 ,1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0
791 ,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0
792 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1
793 ,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1
794 ,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0
795 ,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0
796 ,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0
797 ,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0
798 ,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1
799 ,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0
800 ,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0
801 ,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0
802 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1
803 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1
804 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,1,1,0,0,0
805 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0
806 ,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0
807 ,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0
808 ,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0
809 ,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0
810 ,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0
811 ,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
812 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
813 ,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
814 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0
815 ,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0
816 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0
817 ,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0
818 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0
819 ,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0
820 ,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1
821 ,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0
822 ,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0,0,0,0,0,1,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0
823 ,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
824 ,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
825 ,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
826 ,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0
827 ,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0
828 ,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
829 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1
830 ,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1
831 ,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0
832 ,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0
833 ,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0
834 ,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0
835 ,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0
836 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0
837 ,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0
838 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1
839 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0
840 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,1,1,1,1,0,0
841 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0
842 ,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
843 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0
844 ,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
845 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
846 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
847 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0};
848 xx=0; yy=0;
849 for (int y=430;y<(430+38);++y)
850 {
851 for (int x=337;x<(337+81);x++) {
854 }
855 xx++;
856 }
857 yy++;
858 xx=0;
859 }
860
861 // 16_lable_investment_investment.png
862 // 338 52
863 // 1114 128
864 char lable_investment_investment[]={1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0\
865 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
866 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1
867 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0
868 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
869 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
870 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
871 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
872 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
873 ,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
874 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1
875 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
876 ,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
877 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
878 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
879 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1
880 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
881 ,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
882 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
883 ,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
884 ,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0
885 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1
886 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0
887 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1
888 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
889 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1
890 ,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
891 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
892 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0
893 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
894 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
895 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1
896 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
897 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1
898 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1
899 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
900 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
901 ,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
902 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
903 ,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
904 ,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
905 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1
906 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1
907 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
908 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
909 ,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
910 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
911 ,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0
912 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0
913 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
914 ,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
915 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1
916 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
917 ,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
918 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
919 ,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0
920 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
921 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
922 ,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
923 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0
924 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
925 ,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1
926 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
927 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
928 ,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
929 ,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
930 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
931 ,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
932 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
933 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
934 ,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1
935 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
936 ,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
937 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
938 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
939 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
940 ,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
941 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
942 ,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0
943 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1
944 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1
945 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
946 ,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0
947 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
948 ,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
949 ,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1
950 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
951 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1
952 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
953 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1
954 ,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0
955 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
956 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
957 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1
958 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
959 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1
960 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
961 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1
962 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
963 ,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
964 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
965 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1
966 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1
967 ,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
968 ,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
969 ,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
970 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
971 ,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
972 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
973 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
974 ,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1
975 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
976 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
977 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
978 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1
979 ,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
980 ,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
981 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
982 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1
983 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0
984 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
985 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
986 ,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1
987 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
988 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
989 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0
990 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
991 ,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0
992 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
993 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
994 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1
995 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
996 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
997 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0
998 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
999 ,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1000 ,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1001 ,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
1002 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1003 ,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
1004 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1005 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1006 ,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1007 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
1008 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1009 ,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1010 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0
1011 ,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
1012 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1013 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
1014 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
1015 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1
1016 ,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
1017 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1018 ,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0
1019 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1020 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1021 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1
1022 ,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1023 ,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
1024 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
1025 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1026 ,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1027 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1028 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1029 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
1030 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1031 ,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1032 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1033 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1
1034 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
1035 ,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1036 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0
1037 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1038 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1039 ,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1040 ,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
1041 ,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1
1042 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1
1043 ,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1
1044 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1045 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0
1046 ,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1
1047 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
1048 ,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
1049 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
1050 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1
1051 ,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1052 ,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1053 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0
1054 ,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1055 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0
1056 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1057 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1058 ,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1
1059 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1060 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1061 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0
1062 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1063 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0
1064 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1065 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1066 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
1067 ,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1068 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1069 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1070 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1071 ,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1072 ,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1073 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1074 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1075 ,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
1076 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1077 ,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
1078 ,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1079 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1080 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1081 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
1082 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1083 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1
1084 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1
1085 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0
1086 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1087 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1088 ,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1
1089 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1090 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1091 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
1092 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1093 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0
1094 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1
1095 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1096 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1097 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1098 ,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
1099 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0
1100 ,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
1101 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1102 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1103 ,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1
1104 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
1105 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1106 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1107 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0
1108 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1109 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1110 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
1111 ,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0
1112 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1
1113 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1
1114 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1115 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1116 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1117 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1118 ,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1
1119 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1120 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1
1121 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1122 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1123 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0
1124 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1125 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
1126 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1
1127 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
1128 ,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1
1129 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1130 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1
1131 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,0
1132 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1133 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
1134 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1
1135 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1
1136 ,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1137 ,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1138 ,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1139 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,0,0
1140 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1141 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0
1142 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1143 ,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1
1144 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
1145 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1146 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1147 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1
1148 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1149 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0
1150 ,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
1151 ,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1
1152 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0
1153 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
1154 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1155 ,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1
1156 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1157 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0
1158 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0
1159 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1160 ,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0
1161 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1162 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1163 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1,1,1,1
1164 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1165 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1166 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0
1167 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1168 ,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1169 ,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1170 ,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
1171 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1
1172 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
1173 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
1174 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1175 ,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1176 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
1177 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1178 ,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1179 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1180 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
1181 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0
1182 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
1183 ,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
1184 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1
1185 ,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
1186 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1187 ,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
1188 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1189 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0
1190 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1
1191 ,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1192 ,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
1193 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
1194 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1195 ,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1
1196 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1197 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1198 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
1199 ,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1200 ,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1201 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1202 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1
1203 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
1204 ,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1205 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
1206 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1207 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1208 ,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1209 ,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
1210 ,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1
1211 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1212 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1
1213 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1214 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0
1215 ,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1
1216 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1217 ,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
1218 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
1219 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1220 ,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1221 ,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1222 ,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0
1223 ,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
1224 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0
1225 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1226 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1227 ,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
1228 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1229 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1230 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0
1231 ,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1232 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1233 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1234 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1235 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
1236 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1237 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1238 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
1239 ,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1240 ,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1241 ,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1242 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1243 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
1244 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
1245 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1246 ,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
1247 ,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1248 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1249 ,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1250 ,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
1251 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
1252 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
1253 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1
1254 ,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0
1255 ,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0
1256 ,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1257 ,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1
1258 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1259 ,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0
1260 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1261 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1262 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0
1263 ,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1
1264 ,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
1265 ,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1266 ,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
1267 ,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0
1268 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1269 ,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
1270 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
1271 ,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
1272 ,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1
1273 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
1274 ,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1275 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1276 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1277 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
1278 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1279 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1280 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1281 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1282 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1283 xx=0; yy=0;
1284 for (int y=128;y<(128+52);++y)
1285 {
1286 for (int x=1114;x<(1114+338);x++) {
1287 if (lable_investment_investment[get_index(xx,yy,338)] == 1) {
1289 }
1290 xx++;
1291 }
1292 yy++;
1293 xx=0;
1294 }
1295
1296 // 16_lable_investment_jupiter.png
1297 // 84 20
1298 // 1194 440
1299 char lable_investment_jupiter[]={0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,\
1300 0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,
1301 1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1302 0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,
1303 1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1304 0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,
1305 1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1306 0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
1307 0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1308 0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
1309 0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1310 0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
1311 0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1312 0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
1313 0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1314 0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
1315 0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1316 0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,
1317 1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1318 0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,
1319 1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1320 0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,
1321 1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1322 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
1323 0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1324 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
1325 0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1326 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
1327 0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1328 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
1329 0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1330 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
1331 0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,
1332 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,
1333 0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,
1334 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,
1335 1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,
1336 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,
1337 1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,
1338 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1339 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1340 xx=0; yy=0;
1341 for (int y=440;y<(440+20);++y)
1342 {
1343 for (int x=1194;x<(1194+84);x++) {
1344 if (lable_investment_jupiter[get_index(xx,yy,84)] == 1) {
1346 }
1347 xx++;
1348 }
1349 yy++;
1350 xx=0;
1351 }
1352
1353 // 16_lable_investment_mercury.png
1354 // 101 20
1355 // 337 519
1356 char lable_investment_mercury[]={0,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,\
1357 1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,
1358 0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,
1359 1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,
1360 1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,
1361 1,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,
1362 1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,
1363 0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,
1364 1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,
1365 0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,
1366 0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,
1367 1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,
1368 0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,
1369 1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,
1370 0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,1,1,0,0,0,1,1,0,0,1,1,1,0,0,0,0,
1371 1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,
1372 1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,
1373 0,1,1,0,0,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
1374 0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,
1375 0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,
1376 1,1,1,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,
1377 0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,1,1,0,
1378 0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,
1379 1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,
1380 1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,
1381 1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
1382 0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,1,1,1,0,0,0,
1383 0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,
1384 1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,
1385 0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,
1386 0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,
1387 0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,
1388 1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,
1389 0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,
1390 0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,
1391 0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,
1392 0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,
1393 1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,
1394 1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,
1395 0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,
1396 0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,
1397 0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,
1398 0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,
1399 0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,
1400 0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,
1401 1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,
1402 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1403 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
1404 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,};
1405 xx=0; yy=0;
1406 for (int y=519;y<(519+20);++y)
1407 {
1408 for (int x=337;x<(337+101);x++) {
1409 if (lable_investment_mercury[get_index(xx,yy,101)] == 1) {
1411 }
1412 xx++;
1413 }
1414 yy++;
1415 xx=0;
1416 }
1417
1418 // 16_lable_investment_saturn.png
1419 // 81 20
1420 // 1197 665
1421 char lable_investment_saturn[]={0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0\
1422 ,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1423 ,0,0,0,0,0,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0
1424 ,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
1425 ,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1
1426 ,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1
1427 ,1,1,1,1,1,1,1,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1
1428 ,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0
1429 ,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0
1430 ,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1
1431 ,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0
1432 ,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1
1433 ,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1
1434 ,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,0
1435 ,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0
1436 ,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,1,1,1,0,0,0,0
1437 ,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1
1438 ,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,1,1,1,1,1,1,1,1,1,0
1439 ,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0
1440 ,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0
1441 ,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0
1442 ,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1
1443 ,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1
1444 ,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1
1445 ,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0
1446 ,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1
1447 ,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1
1448 ,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1
1449 ,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0
1450 ,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0
1451 ,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1
1452 ,1,1,1,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0
1453 ,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1
1454 ,0,0,0,0,1,1,1,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1
1455 ,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0
1456 ,0,1,1,1,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0
1457 ,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1
1458 ,1,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0
1459 ,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1};
1460 xx=0; yy=0;
1461 for (int y=665;y<(665+20);++y)
1462 {
1463 for (int x=1197;x<(1197+81);x++) {
1464 if (lable_investment_saturn[get_index(xx,yy,81)] == 1) {
1466 }
1467 xx++;
1468 }
1469 yy++;
1470 xx=0;
1471 }
1472
1473 // 16_lable_investment_venus.png
1474 // 66 20
1475 // 336 705
1476 char lable_investment_venus[]={1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,\
1477 0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,0,0,1,1,
1478 1,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,
1479 1,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,
1480 1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,
1481 1,1,1,1,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,
1482 0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,1,1,1,0,0,0,0,1,1,1,0,0,0,
1483 0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,
1484 1,1,1,0,0,0,0,1,1,1,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,
1485 0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,
1486 1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,
1487 1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,
1488 0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,
1489 1,1,0,0,0,0,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,
1490 1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,
1491 1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,
1492 1,1,1,0,0,0,1,1,1,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,
1493 0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,0,1,1,1,0,0,0,0,
1494 0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,
1495 0,0,0,1,1,1,1,1,1,1,0,0,1,1,1,0,0,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,
1496 0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,0,0,1,
1497 1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,
1498 1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,
1499 0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,
1500 0,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,
1501 1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,
1502 0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,
1503 0,1,1,1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,1,
1504 0,0,0,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,
1505 0,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,
1506 1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,
1507 0,0,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0};
1508 xx=0; yy=0;
1509 for (int y=705;y<(705+20);++y)
1510 {
1511 for (int x=336;x<(336+66);x++) {
1512 if (lable_investment_venus[get_index(xx,yy,66)] == 1) {
1514 }
1515 xx++;
1516 }
1517 yy++;
1518 xx=0;
1519 }
1520 }
1521
1524 {
1528 dl;
1529
1531 {
1532 color=image[i];
1534 std::get<2>(color)*255.0f);
1535 }
1536 out.close();
1537 }
1538
1539 int main()
1540 {
1543
1545
1546 generate_noise_image(image1, width, height);
1547
1548 std::cout << "saving: 16_draw_investment1.ppm." << std::endl;
1549 save_image(image1,width,height,"16_draw_investment1.ppm");
1550
1553
1554 std::tuple<float, float, float> fcolor=std::make_tuple(0.5294117647f,0.8235294118f,\
1555 0.8078431373f);
1557 0.3921568627f);
1559
1562
1564
1567
1568 // radial gradient
1571
1574
1575 generate_radial_gradient_image(image3,fcolor,tcolor,900,900);
1576
1578 save_image(image3,900,900,"16_draw_investment4.ppm");
1579
1580 // Repeating texture generation
1583
1585 generate_repeating_texture_image(image4,fcolor,73,65);
1586
1589
1590 // Render repeating texture
1593
1594 render_repeating_texture_image(image4,73,65,image5,900,900);
1595
1598
1599 // Do cookie cut
1602
1603 do_cookie_cut(image1,width,height,image6,900,900,350,0);
1604
1607
1608 // Add honeycomb
1609 add_honeycomb(image6,image3,image5,900,900);
1610
1613
1614 // Stamp cookie
1615 stamp_cookie(image1,width,height,image6,900,900,350,0);
1616
1619
1620 // Create Doughnut
1625 clear_image(image7,fcolor,width,height);
1627 draw_filled_wedge(801,491,209,0,79,image7,fcolor,width,height);
1630 draw_line(image7,coords,fcolor,width,height);
1633 // fcolor=std::make_tuple(1.0f,0.0f,1.0f);
1634 // draw_filled_wedge(801,491,156,0,60,image7,fcolor,width,height);
1642 // fcolor=std::make_tuple(1.0f,0.0f,1.0f);
1657 draw_filled_circle(801,491,153,image7,fcolor,width,height);
1658
1660 draw_labels(image7,fcolor,width,height);
1661
1664
1665 // Add doughnut to image1
1669 if (image7[get_index(x,y,width)] != fcolor) {
1670 image1[get_index(x,y,width)]=image7[get_index(x,y,width)];
1671 }
1672 }
1673 }
1674
1677
1678 return 0;
1679 }
17_colab_peacock.cpp - 12051 bytes.
1 // Compile: clang++ -std=c++17 17_colab_peacock.cpp -o 17_colab_peacock

3
6 #include <tuple>
7 #include <vector>
8 #include <random>
9 #include <cmath>
11
13 {
19 return true;
20 else
21 return false;
22 }
23
25 {
27 }
28
30 {
32 }
33
35 height)
36 {
40 }
41 }
42 }
43
46 {
49
51 std::mt19937 mt(rd());
53
56 rndnum=dist(mt);
59 }
60 }
61 }
62
66 {
75

84 }
85 }
86 }
87
90 {
94
103 }
104 }
105 }
106
109 {
113 dx = x2 - x1; dy = y2 - y1;
114 if (dx == 0)
115 {
116 if (y2 < y1) std::swap(y1, y2);
117 for (y = y1; y <= y2; y++)
119 return;
120 }
121 if (dy == 0)
122 {
123 if (x2 < x1) std::swap(x1, x2);
124 for (x = x1; x <= x2; x++)
126 return;
127 }
129 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
130 if (dy1 <= dx1)
131 {
132 if (dx >= 0)
133 {
134 x = x1; y = y1; xe = x2;
135 }
136 else
137 {
138 x = x2; y = y2; xe = x1;
139 }
141 for (i = 0; x<xe; i++)
142 {
143 x = x + 1;
144 if (px<0)
145 px = px + 2 * dy1;
146 else
147 {
149 px = px + 2 * (dy1 - dx1);
150 }
152 }
153 }
154 else
155 {
156 if (dy >= 0)
157 {
158 x = x1; y = y1; ye = y2;
159 }
160 else
161 {
162 x = x2; y = y2; ye = y1;
163 }
165 for (i = 0; y<ye; i++)
166 {
167 y = y + 1;
168 if (py <= 0)
169 py = py + 2 * dx1;
170 else
171 {
173 py = py + 2 * (dx1 - dy1);
174 }
176 }
177 }
178 }
179
181 {
182 int code=0;
183 if(y >= height)
184 code |= 1; //top
185 else if(y < 0)
187 if(x >= width)
189 else if (x < 0)
190 code |= 8; //left
191 return(code);
192 }
193
196 {
206 {
211 {
212 int x, y;
215 {
216 x = x1 + (x2 - x1) * (height - y1) / (y2 - y1);
217 y = height - 1;
218 }
220 {
221 x = x1 + (x2 - x1) * -y1 / (y2 - y1);
222 y = 0;
223 }
225 {
226 y = y1 + (y2 - y1) * (width - x1) / (x2 - x1);
227 x = width - 1;
228 }
229 else //left
230 {
231 y = y1 + (y2 - y1) * -x1 / (x2 - x1);
232 x = 0;
233 }
235 {
236 x1 = x; y1 = y;
238 }
240 {
241 x2 = x; y2 = y;
243 }
244 }
245 }
247 if(accept)
248 {
249 x3 = x1;
250 x4 = x2;
251 y3 = y1;
252 y4 = y2;
254 return 1;
255 }
256 else
257 {
258 x3 = x4 = y3 = y4 = 0;
260 return 0;
261 }
262 }
263
266 {
270 }
271
274 {
278 dl;
279
281 {
282 color=image[i];
284 std::get<2>(color)*255.0f);
285 }
286 out.close();
287 }
288
289 void draw(std::vector<std::tuple<float, float, float>> &image,std::tuple<int, int, i\
290 nt, int> &coords,std::vector<std::tuple<float,float,float>> &colors,int width,int he
291 ight,int x_cen,int y_cen,double degrees,int length,int color)
292 {
295 draw_line(image,coords,colors[color],width,height);
296 }
297 std::cout << "L " << std::get<0>(coords) << " " << std::get<1>(coords) << " " << st\
298 d::get<2>(coords) << " " << std::get<3>(coords) << " " << color << std::endl;
299 }
300
301 void parse_draw_line_from_file(const std::string str,std::vector<std::tuple<float, f\
302 loat, float>> &image,std::vector<std::tuple<float,float,float>> &colors,int width,in
303 t height)
304 {
305 size_t start;
306 size_t end = 0;
308
310 {
313 }
314
315 std::tuple<int, int, int, int> coords=std::make_tuple(stoi(out[1]),stoi(out[2]),sto\
316 i(out[3]),stoi(out[4]));
317 draw_line(image,coords,colors[stoi(out[5])],width,height);
318 }
319
320 void parse_draw_marker_from_file(const std::string str,std::vector<std::tuple<float,\
321 float, float>> &image,std::vector<std::tuple<float,float,float>> &colors,int width,
322 int height)
323 {
324 size_t start;
325 size_t end = 0;
327
329 {
332 }
333
334 int x=stoi(out[1]),y=stoi(out[2]),color=stoi(out[3]);
335
336 // Draw Marker

337 image[get_index(x-1,y-1,width)]=colors[color];
338 image[get_index(x,y-1,width)]=colors[color];
339 image[get_index(x+1,y-1,width)]=colors[color];
340 image[get_index(x+1,y,width)]=colors[color];
341 image[get_index(x+1,y+1,width)]=colors[color];
342 image[get_index(x,y+1,width)]=colors[color];
343 image[get_index(x-1,y+1,width)]=colors[color];
344 image[get_index(x-1,y,width)]=colors[color];
345 image[get_index(x,y,width)]=colors[color];
346 }
347
348 void parse_draw_spot_from_file(const std::string str,std::vector<std::tuple<float, f\
349 loat, float>> &image,std::vector<std::tuple<float,float,float>> &colors,int width,in
350 t height)
351 {
352 size_t start;
353 size_t end = 0;
354 int radius=5;
356
358 {
361 }
362
363 int x=stoi(out[1]),y=stoi(out[2]),color=stoi(out[3]);
364
365 int x0 = 0;
367 int d = 3 - 2 * radius;
369
371 {
372 for (int i = sx; i <= ex; i++)
373 image[get_index(i, ny, width)]=colors[color];
374 };
375
376 while (y0 >= x0)
377 {
378 drawline(x - x0, x + x0, y - y0);
379 drawline(x - y0, x + y0, y - x0);

380 drawline(x - x0, x + x0, y + y0);
381 drawline(x - y0, x + y0, y + x0);
382 if (d < 0) d += 4 * x0++ + 6;
383 else d += 4 * (x0++ - y0--) + 10;
384 }
385 }
386
387 int main()
388 {
392 std::vector<std::tuple<float,float,float>> colors;
393 colors.push_back(std::make_tuple(0.5f,0.5f,0.5f));// Medium Grey
394 colors.push_back(std::make_tuple(0.862745098f,0.862745098f,0.862745098f));// Red
395 colors.push_back(std::make_tuple(1.0f,1.0f,1.0f));// Black
396 colors.push_back(std::make_tuple(0.7f,0.7f,0.7f));// Blue
397 colors.push_back(std::make_tuple(0.6f,0.6f,0.6f));// Purple
398 colors.push_back(std::make_tuple(0.2f,0.2f,0.2f));// Light Green
399 colors.push_back(std::make_tuple(0.1f,0.1f,0.1f));// Green
400 colors.push_back(std::make_tuple(0.4f,0.4f,0.4f));// Cyan
401 float deg=0.0;
402 int len=0,len2=0;
403
404 int width=1600;int height=900;
405
408
409 generate_noise_image(image, width, height);
410
411 std::tuple<float, float, float> fcolor=std::make_tuple(0.05882352941f,0.0862745098f\
412 ,0.1254901961f);
414 0.3490196078f);
416
417 blended_two_images(image,image2,width,height,0.9);
418
419 // read 17_colab.txt and draw it
420 std::ifstream infile("17_colab_peacock.txt");

423 {
424 if (startsWithCaseInsensitive(line,"L")) {
425 parse_draw_line_from_file(line,image,colors,width,height);
426 }
427 if (startsWithCaseInsensitive(line,"M")) {
428 parse_draw_marker_from_file(line,image,colors,width,height);
429 }
430 if (startsWithCaseInsensitive(line,"S")) {
431 parse_draw_spot_from_file(line,image,colors,width,height);
432 }
433 }
434 infile.close();
435
436 save_image(image,width,height,"17_colab_peacock.ppm");
437 return 0;
438 }
17_colab_peacock.txt - 15936 bytes.
1 L 1321 223 1202 151 0

2 L 1321 223 1416 160 0
3 L 1321 223 1304 335 0
4 L 1321 223 1247 198 0
5 L 1321 223 1372 280 0
6 L 1321 223 1310 271 0
7 L 1321 223 1368 238 0
8 L 1321 223 1363 189 0
9 L 1321 223 1369 256 0
10 L 1321 223 1330 337 0
11 L 1321 223 1333 129 0
12 L 1321 223 1452 226 0
13 L 1321 223 1234 195 0
14 L 1321 223 1251 194 0
15 L 1321 223 1259 149 0
16 L 1321 223 1239 178 0
17 L 1321 223 1360 306 0
18 L 1321 223 1354 171 0
19 L 1321 223 1255 282 0
20 L 1321 223 1429 218 0
21 L 1321 223 1287 175 0
22 L 1321 223 1345 285 0
23 L 1321 223 1303 145 0
24 L 1321 223 1452 264 0

25 L 1321 223 1256 241 0
26 L 1321 223 1403 196 0
27 L 1321 223 1315 290 0
28 L 1321 223 1258 271 0
29 L 1321 223 1426 215 0
30 L 1321 223 1325 168 0
31 L 1321 223 1415 260 0
32 L 1321 223 1331 280 0
33 L 1321 223 1361 129 0
34 L 1321 223 1262 223 0
35 L 1321 223 1433 290 0
36 L 1321 223 1320 283 0
37 L 1321 223 1290 358 0
38 L 1321 223 1323 164 0
39 L 1321 223 1423 283 0
40 L 1321 223 1342 308 0
41 L 1321 223 1309 305 0
42 L 1321 223 1243 113 0
43 L 1321 223 1295 305 0
44 L 1321 223 1410 204 0
45 L 1321 223 1271 81 0
46 L 1321 223 1385 201 0
47 L 1321 223 1333 306 0
48 L 1321 223 1419 306 0
49 L 1321 223 1262 257 0
50 L 1321 223 1380 269 0
51 L 1321 223 1260 256 0
52 L 1321 223 1295 270 0
53 L 1321 223 1258 87 0
54 L 1321 223 1246 190 0
55 L 1321 223 1292 112 0
56 L 1321 223 1393 202 0
57 L 1321 223 1461 246 0
58 L 1321 223 1393 293 0
59 L 1321 223 1239 261 0
60 L 1321 223 1408 297 0
61 L 1321 223 1325 302 0
62 L 1321 223 1435 258 0
63 L 1321 223 1379 216 0
64 L 1321 223 1326 280 0
65 L 1321 223 1356 187 0
66 L 1321 223 1348 367 0
67 L 1321 223 1407 193 0

68 L 1321 223 1247 203 0
69 L 1321 223 1343 293 0
70 L 1321 223 1445 293 0
71 L 1321 223 1285 350 0
72 L 1321 223 1240 182 0
73 L 1321 223 1452 182 0
74 L 1321 223 1354 272 0
75 L 1321 223 1247 147 0
76 L 1321 223 1300 279 0
77 L 1321 223 1312 139 0
78 L 1321 223 1290 282 0
79 L 1321 223 1403 218 0
80 L 1321 223 1420 125 0
81 L 1321 223 1385 114 0
82 L 1321 223 1398 203 0
83 L 1321 223 1406 177 0
84 L 1321 223 1232 255 0
85 L 1321 223 1396 338 0
86 L 1321 223 1378 332 0
87 L 1321 223 1443 198 0
88 L 1321 223 1369 319 0
89 L 1321 223 1246 168 0
90 L 1321 223 1267 241 0
91 L 1321 223 1273 95 0
92 L 1321 223 1325 297 0
93 L 1321 223 1290 348 0
94 L 1321 223 1269 251 0
95 L 1321 223 1390 301 0
96 L 1321 223 1236 219 0
97 L 1321 223 1399 250 0
98 L 1321 223 1388 236 0
99 L 1321 223 1236 219 0
100 L 1321 223 1268 207 1
101 L 1321 223 1002 211 1
102 L 1321 223 1026 224 1
103 L 1321 223 1014 247 0
104 L 1321 223 1037 260 1
105 L 1321 223 1025 277 1
106 L 1321 223 1009 307 1
107 L 1321 223 1200 370 0
108 L 1321 223 1264 405 0
109 L 721 297 730 370 0
110 L 721 297 778 343 0

111 L 721 297 738 343 0
112 L 721 297 773 283 0
113 L 721 297 724 382 0
114 L 721 297 660 407 0
115 L 721 297 699 238 0
116 L 721 297 771 286 0
117 L 721 297 692 442 0
118 L 721 297 649 239 0
119 L 721 297 754 390 0
120 L 721 297 718 410 0
121 L 721 297 699 379 0
122 L 721 297 780 334 0
123 L 721 297 614 343 0
124 L 721 297 688 441 0
125 L 721 297 628 216 0
126 L 721 297 811 303 0
127 L 721 297 768 239 0
128 L 721 297 795 253 0
129 L 721 297 813 327 0
130 L 721 297 777 290 0
131 L 721 297 667 289 0
132 L 721 297 728 349 0
133 L 721 297 653 346 0
134 L 721 297 751 213 0
135 L 721 297 792 350 0
136 L 721 297 808 289 0
137 L 721 297 811 290 0
138 L 721 297 809 259 0
139 L 721 297 493 308 0
140 L 721 297 707 354 0
141 L 721 297 719 167 0
142 L 721 297 655 418 0
143 L 721 297 593 317 0
144 L 721 297 789 294 0
145 L 721 297 801 260 0
146 L 721 297 775 284 0
147 L 721 297 618 325 0
148 L 721 297 631 312 0
149 L 721 297 695 212 0
150 L 721 297 809 344 0
151 L 721 297 665 191 0
152 L 721 297 755 237 0
153 L 721 297 802 298 0

154 L 721 297 684 364 0
155 L 721 297 744 392 0
156 L 721 297 706 375 0
157 L 721 297 756 362 0
158 L 721 297 780 346 0
159 L 721 297 791 357 0
160 L 721 297 671 276 0
161 L 721 297 646 184 0
162 L 721 297 719 405 0
163 L 721 297 687 414 0
164 L 721 297 642 256 0
165 L 721 297 730 217 0
166 L 721 297 790 273 0
167 L 721 297 623 313 0
168 L 721 297 766 225 0
169 L 721 297 658 388 0
170 L 721 297 701 358 0
171 L 721 297 661 266 0
172 L 721 297 677 327 0
173 L 721 297 629 320 0
174 L 721 297 781 278 0
175 L 721 297 795 237 0
176 L 721 297 776 233 0
177 L 721 297 792 228 0
178 L 721 297 661 301 0
179 L 721 297 758 352 0
180 L 721 297 744 372 0
181 L 721 297 780 369 0
182 L 721 297 745 345 0
183 L 721 297 618 266 0
184 L 721 297 730 243 0
185 L 721 297 707 242 0
186 L 721 297 815 285 0
187 L 721 297 669 292 0
188 L 721 297 724 362 0
189 L 721 297 758 252 0
190 L 721 297 701 246 0
191 L 721 297 672 373 0
192 L 721 297 702 153 0
193 L 721 297 739 226 0
194 L 721 297 757 372 0
195 L 721 297 636 201 0
196 L 721 297 697 402 0

197 L 721 297 799 307 0
198 L 721 297 759 244 0
199 L 721 297 665 191 0
200 L 721 297 803 353 0
201 L 721 297 750 235 0
202 L 721 297 753 387 0
203 L 721 297 589 368 0
204 L 721 297 662 405 0
205 L 721 297 748 391 0
206 L 721 297 729 226 0
207 L 721 297 758 264 0
208 L 721 297 801 277 0
209 L 721 297 1002 211 0
210 L 721 297 1026 224 0
211 L 721 297 1014 247 1
212 L 721 297 1037 260 0
213 L 721 297 1025 277 0
214 L 721 297 1009 307 0
215 L 721 297 879 423 0
216 L 721 297 866 439 0
217 L 721 297 844 458 0
218 L 1091 592 758 623 0
219 L 1091 592 1010 739 0
220 L 1091 592 1160 722 0
221 L 1091 592 904 523 0
222 L 1091 592 1031 705 0
223 L 1091 592 1314 673 0
224 L 1091 592 1220 489 0
225 L 1091 592 1048 740 0
226 L 1091 592 920 542 0
227 L 1091 592 985 465 0
228 L 1091 592 1125 784 1
229 L 1091 592 1137 465 0
230 L 1091 592 1136 762 0
231 L 1091 592 802 661 0
232 L 1091 592 977 674 0
233 L 1091 592 1031 737 0
234 L 1091 592 1000 691 0
235 L 1091 592 1077 744 0
236 L 1091 592 967 498 0
237 L 1091 592 906 514 0
238 L 1091 592 1042 752 0
239 L 1091 592 1036 737 0

240 L 1091 592 1001 457 0
241 L 1091 592 1145 775 0
242 L 1091 592 1200 621 0
243 L 1091 592 945 553 0
244 L 1091 592 1169 472 0
245 L 1091 592 922 605 0
246 L 1091 592 1245 623 0
247 L 1091 592 1036 747 0
248 L 1091 592 1216 563 0
249 L 1091 592 1217 710 0
250 L 1091 592 993 623 0
251 L 1091 592 974 554 0
252 L 1091 592 1156 501 0
253 L 1091 592 1242 481 0
254 L 1091 592 1003 441 0
255 L 1091 592 1218 471 0
256 L 1091 592 1312 602 0
257 L 1091 592 1196 535 0
258 L 1091 592 1171 653 0
259 L 1091 592 956 606 0
260 L 1091 592 1137 471 0
261 L 1091 592 1222 722 0
262 L 1091 592 936 508 0
263 L 1091 592 1094 445 0
264 L 1091 592 979 701 0
265 L 1091 592 1086 395 0
266 L 1091 592 961 573 0
267 L 1091 592 1159 709 0
268 L 1091 592 961 645 0
269 L 1091 592 936 473 0
270 L 1091 592 992 647 0
271 L 1091 592 1222 718 0
272 L 1091 592 1270 534 0
273 L 1091 592 974 558 0
274 L 1091 592 1071 407 0
275 L 1091 592 913 665 0
276 L 1091 592 1131 702 0
277 L 1091 592 1020 493 0
278 L 1091 592 1152 728 0
279 L 1091 592 1003 444 0
280 L 1091 592 1049 724 0
281 L 1091 592 1196 577 0
282 L 1091 592 979 668 0

283 L 1091 592 1209 680 0
284 L 1091 592 1156 692 0
285 L 1091 592 1276 638 0
286 L 1091 592 916 558 0
287 L 1091 592 1211 461 0
288 L 1091 592 999 660 0
289 L 1091 592 930 575 0
290 L 1091 592 1138 454 0
291 L 1091 592 1198 573 0
292 L 1091 592 1221 538 0
293 L 1091 592 1152 468 0
294 L 1091 592 1172 530 0
295 L 1091 592 1024 448 0
296 L 1091 592 1131 473 0
297 L 1091 592 1035 414 0
298 L 1091 592 1122 460 0
299 L 1091 592 974 731 0
300 L 1091 592 974 449 0
301 L 1091 592 1010 711 0
302 L 1091 592 1109 450 0
303 L 1091 592 1135 502 0
304 L 1091 592 1073 725 0
305 L 1091 592 1226 555 0
306 L 1091 592 957 701 0
307 L 1091 592 1277 568 0
308 L 1091 592 1002 520 0
309 L 1091 592 1139 766 0
310 L 1091 592 1029 692 0
311 L 1091 592 1157 675 0
312 L 1091 592 1156 448 0
313 L 1091 592 1148 704 0
314 L 1091 592 1272 552 0
315 L 1091 592 1183 473 0
316 L 1091 592 1024 701 0
317 L 1091 592 1067 425 0
318 L 1091 592 1200 370 1
319 L 1091 592 1264 405 1
320 L 1091 592 879 423 1
321 L 1091 592 866 439 1
322 L 1091 592 844 458 1
323 L 1196 535 1385 449 1
324 L 1385 449 1515 391 0
325 L 1312 602 1355 604 1

326 L 1355 604 1398 565 0
327 L 1355 604 1414 596 0
328 L 1355 604 1414 618 0
329 L 1355 604 1398 647 0
330 L 1091 592 1314 673 0
331 L 1314 673 1376 660 3
332 L 1314 673 1368 691 1
333 L 1314 673 1339 720 4
334 L 1091 592 1160 637 0
335 L 1160 637 1214 672 1
336 L 1214 672 1257 700 0
337 L 1222 718 1249 741 1
338 L 1249 741 1305 750 0
339 L 1249 741 1253 802 0
340 L 1125 784 1128 863 0
341 L 1136 762 1158 845 1
342 L 1145 775 1168 841 1
343 L 1091 592 831 618 1
344 L 1091 592 876 573 1
345 L 1091 592 816 534 1
346 L 1091 592 808 702 1
347 L 876 573 584 551 0
348 L 831 618 544 683 4
349 L 808 702 544 683 0
350 L 802 661 544 683 1
351 L 816 534 538 515 0
352 L 758 623 694 731 1
353 L 802 661 584 551 3
354 L 831 618 584 551 0
355 L 831 618 756 580 3
356 L 758 623 356 623 3
357 L 758 623 356 623 3
358 L 493 308 426 442 4
359 L 493 308 437 290 1
360 L 493 308 387 243 4
361 L 387 243 316 198 0
362 L 493 308 440 214 3
363 L 440 214 399 137 0
364 L 426 442 406 413 0
365 L 426 442 379 404 0
366 L 426 442 366 434 0
367 L 426 442 393 451 0
368 L 426 442 314 522 1

369 L 314 522 277 598 0
370 L 314 522 355 589 3
371 L 355 589 325 604 1
372 L 325 604 356 623 0
373 L 277 598 285 624 4
374 L 426 442 511 470 0
375 L 511 470 570 442 4
376 L 570 442 721 297 0
377 L 570 442 422 549 7
378 L 422 549 402 509 5
379 L 422 549 326 574 6
380 L 326 574 232 574 0
381 L 422 549 538 515 4
382 L 538 515 491 508 0
383 L 538 515 476 486 0
384 L 538 515 522 483 0
385 L 285 624 189 692 3
386 L 189 692 162 705 0
387 L 356 623 315 654 0
388 L 356 623 342 663 0
389 L 356 623 383 658 1
390 L 356 623 307 635 0
391 L 356 623 407 654 0
392 L 356 623 420 646 0
393 L 356 623 442 641 0
394 L 544 683 407 654 1
395 L 544 683 420 646 1
396 L 544 683 442 641 1
397 L 422 549 369 593 0
398 L 369 593 266 673 0
399 L 266 673 224 732 0
400 L 224 732 154 790 1
401 L 154 790 110 814 0
402 L 266 673 245 709 0
403 L 266 673 236 679 0
404 L 422 549 415 594 1
405 L 415 594 383 658 0
406 L 422 549 356 623 3
407 L 422 549 544 683 3
408 L 538 515 503 597 0
409 L 503 597 544 683 3
410 L 503 597 584 551 4
411 L 426 442 509 460 0

412 L 509 460 584 551 1
413 L 356 623 275 768 0
414 L 275 768 226 803 4
415 L 226 803 185 828 0
416 L 275 768 218 846 3
417 L 218 846 145 883 0
418 L 356 623 309 643 0
419 L 356 623 292 645 0
420 L 356 623 359 685 0
421 L 356 623 387 614 1
422 L 356 623 427 646 0
423 L 356 623 288 648 0
424 L 356 623 299 658 3
425 L 356 623 392 581 3
426 L 356 623 327 554 0
427 L 356 623 330 639 0
428 L 356 623 325 643 1
429 L 356 623 327 637 0
430 L 356 623 283 628 0
431 L 356 623 338 668 0
432 L 356 623 402 659 0
433 L 356 623 337 661 4
434 L 356 623 317 600 3
435 L 356 623 382 613 0
436 L 356 623 340 649 0
437 L 356 623 349 557 0
438 L 356 623 353 694 1
439 L 356 623 320 616 0
440 L 356 623 376 640 0
441 L 356 623 372 562 3
442 L 356 623 351 598 0
443 L 426 442 492 496 0
444 L 426 442 414 545 0
445 L 426 442 494 392 4
446 L 426 442 367 492 0
447 L 426 442 407 527 0
448 L 426 442 371 510 3
449 L 426 442 357 409 1
450 L 426 442 359 518 0
451 L 426 442 501 445 0
452 L 426 442 356 382 3
453 L 426 442 332 489 0
454 L 426 442 376 535 0

455 L 426 442 328 386 0
456 L 426 442 341 452 0
457 L 426 442 328 470 4
458 L 426 442 440 524 0
459 L 426 442 317 457 0
460 L 426 442 327 397 0
461 L 426 442 524 443 3
462 L 426 442 490 351 0
463 L 426 442 419 537 0
464 L 426 442 330 482 1
465 L 426 442 320 401 1
466 L 426 442 334 462 1
467 L 426 442 539 421 1
468 L 426 442 336 513 0
469 L 426 442 448 526 0
470 L 426 442 435 536 0
471 L 426 442 312 449 0
472 L 426 442 369 520 0
473 L 426 442 329 480 3
474 L 426 442 504 379 0
475 L 426 442 466 540 0
476 L 426 442 357 512 0
477 L 426 442 484 505 0
478 L 426 442 346 523 3
479 L 426 442 371 360 4
480 L 426 442 433 346 0
481 L 426 442 524 466 0
482 L 426 442 500 358 1
483 L 426 442 530 447 1
484 L 426 442 482 501 1
485 L 426 442 320 441 0
486 L 426 442 506 445 3
487 L 426 442 519 384 0
488 M 1202 151 2
489 M 1416 160 2
490 M 1304 335 2
491 M 1247 198 2
492 M 1372 280 2
493 M 1310 271 2
494 M 1368 238 2
495 M 1363 189 2
496 M 1369 256 2
497 M 1330 337 2

498 M 1333 129 2
499 M 1452 226 2
500 M 1234 195 2
501 M 1251 194 2
502 M 1259 149 2
503 M 1239 178 2
504 M 1360 306 2
505 M 1354 171 2
506 M 1255 282 2
507 M 1429 218 2
508 M 1287 175 2
509 M 1345 285 2
510 M 1303 145 2
511 M 1452 264 2
512 M 1256 241 2
513 M 1403 196 2
514 M 1315 290 2
515 M 1258 271 2
516 M 1426 215 2
517 M 1325 168 2
518 M 1415 260 2
519 M 1331 280 2
520 M 1361 129 2
521 M 1262 223 2
522 M 1433 290 2
523 M 1320 283 2
524 M 1290 358 2
525 M 1323 164 2
526 M 1423 283 2
527 M 1342 308 2
528 M 1309 305 2
529 M 1243 113 2
530 M 1295 305 2
531 M 1410 204 2
532 M 1271 81 2
533 M 1385 201 2
534 M 1333 306 2
535 M 1419 306 2
536 M 1262 257 2
537 M 1380 269 2
538 M 1260 256 2
539 M 1295 270 2
540 M 1258 87 2
541 M 1246 190 2
542 M 1292 112 2
543 M 1393 202 2
544 M 1461 246 2
545 M 1393 293 2
546 M 1239 261 2
547 M 1408 297 2
548 M 1325 302 2
549 M 1435 258 2
550 M 1379 216 2
551 M 1326 280 2
552 M 1356 187 2
553 M 1348 367 2
554 M 1407 193 2
555 M 1247 203 2
556 M 1343 293 2
557 M 1445 293 2
558 M 1285 350 2
559 M 1240 182 2
560 M 1452 182 2
561 M 1354 272 2
562 M 1247 147 2
563 M 1300 279 2
564 M 1312 139 2
565 M 1290 282 2
566 M 1403 218 2
567 M 1420 125 2
568 M 1385 114 2
569 M 1398 203 2
570 M 1406 177 2
571 M 1232 255 2
572 M 1396 338 2
573 M 1378 332 2
574 M 1443 198 2
575 M 1369 319 2
576 M 1246 168 2
577 M 1267 241 2
578 M 1273 95 2
579 M 1325 297 2
580 M 1290 348 2
581 M 1269 251 2
582 M 1390 301 2
583 M 1236 219 2

584 M 1399 250 2
585 M 1388 236 2
586 M 1236 219 2
587 M 1268 207 2
588 M 1002 211 2
589 M 1026 224 2
590 M 1014 247 2
591 M 1037 260 2
592 M 1025 277 2
593 M 1009 307 2
594 M 730 370 2
595 M 778 343 2
596 M 738 343 2
597 M 773 283 2
598 M 724 382 2
599 M 660 407 2
600 M 699 238 2
601 M 771 286 2
602 M 692 442 2
603 M 649 239 2
604 M 754 390 2
605 M 718 410 2
606 M 699 379 2
607 M 780 334 2
608 M 614 343 2
609 M 688 441 2
610 M 628 216 2
611 M 811 303 2
612 M 768 239 2
613 M 795 253 2
614 M 813 327 2
615 M 777 290 2
616 M 667 289 2
617 M 728 349 2
618 M 653 346 2
619 M 751 213 2
620 M 792 350 2
621 M 808 289 2
622 M 811 290 2
623 M 809 259 2
624 M 493 308 2
625 M 707 354 2
626 M 719 167 2

627 M 655 418 2
628 M 593 317 2
629 M 789 294 2
630 M 801 260 2
631 M 775 284 2
632 M 618 325 2
633 M 631 312 2
634 M 695 212 2
635 M 809 344 2
636 M 665 191 2
637 M 755 237 2
638 M 802 298 2
639 M 684 364 2
640 M 744 392 2
641 M 706 375 2
642 M 756 362 2
643 M 780 346 2
644 M 791 357 2
645 M 671 276 2
646 M 646 184 2
647 M 719 405 2
648 M 687 414 2
649 M 642 256 2
650 M 730 217 2
651 M 790 273 2
652 M 623 313 2
653 M 766 225 2
654 M 658 388 2
655 M 701 358 2
656 M 661 266 2
657 M 677 327 2
658 M 629 320 2
659 M 781 278 2
660 M 795 237 2
661 M 776 233 2
662 M 792 228 2
663 M 661 301 2
664 M 758 352 2
665 M 744 372 2
666 M 780 369 2
667 M 745 345 2
668 M 618 266 2
669 M 730 243 2

670 M 707 242 2
671 M 815 285 2
672 M 669 292 2
673 M 724 362 2
674 M 758 252 2
675 M 701 246 2
676 M 672 373 2
677 M 702 153 2
678 M 739 226 2
679 M 757 372 2
680 M 636 201 2
681 M 697 402 2
682 M 799 307 2
683 M 759 244 2
684 M 665 191 2
685 M 803 353 2
686 M 750 235 2
687 M 753 387 2
688 M 589 368 2
689 M 662 405 2
690 M 748 391 2
691 M 729 226 2
692 M 758 264 2
693 M 801 277 2
694 M 758 623 2
695 M 1010 739 2
696 M 1160 722 2
697 M 904 523 2
698 M 1031 705 2
699 M 1314 673 2
700 M 1220 489 2
701 M 1048 740 2
702 M 920 542 2
703 M 985 465 2
704 M 1125 784 2
705 M 1137 465 2
706 M 1136 762 2
707 M 802 661 2
708 M 977 674 2
709 M 1031 737 2
710 M 1000 691 2
711 M 1077 744 2
712 M 967 498 2

713 M 906 514 2
714 M 1042 752 2
715 M 1036 737 2
716 M 1001 457 2
717 M 1145 775 2
718 M 1200 621 2
719 M 945 553 2
720 M 1169 472 2
721 M 922 605 2
722 M 1245 623 2
723 M 1036 747 2
724 M 1216 563 2
725 M 1217 710 2
726 M 993 623 2
727 M 974 554 2
728 M 1156 501 2
729 M 1242 481 2
730 M 1003 441 2
731 M 1218 471 2
732 M 1312 602 2
733 M 1196 535 2
734 M 1171 653 2
735 M 956 606 2
736 M 1137 471 2
737 M 1222 722 2
738 M 936 508 2
739 M 1094 445 2
740 M 979 701 2
741 M 1086 395 2
742 M 961 573 2
743 M 1159 709 2
744 M 961 645 2
745 M 936 473 2
746 M 992 647 2
747 M 1222 718 2
748 M 1270 534 2
749 M 974 558 2
750 M 1071 407 2
751 M 913 665 2
752 M 1131 702 2
753 M 1020 493 2
754 M 1152 728 2
755 M 1003 444 2

756 M 1049 724 2
757 M 1196 577 2
758 M 979 668 2
759 M 1209 680 2
760 M 1156 692 2
761 M 1276 638 2
762 M 916 558 2
763 M 1211 461 2
764 M 999 660 2
765 M 930 575 2
766 M 1138 454 2
767 M 1198 573 2
768 M 1221 538 2
769 M 1152 468 2
770 M 1172 530 2
771 M 1024 448 2
772 M 1131 473 2
773 M 1035 414 2
774 M 1122 460 2
775 M 974 731 2
776 M 974 449 2
777 M 1010 711 2
778 M 1109 450 2
779 M 1135 502 2
780 M 1073 725 2
781 M 1226 555 2
782 M 957 701 2
783 M 1277 568 2
784 M 1002 520 2
785 M 1139 766 2
786 M 1029 692 2
787 M 1157 675 2
788 M 1156 448 2
789 M 1148 704 2
790 M 1272 552 2
791 M 1183 473 2
792 M 1024 701 2
793 M 1067 425 2
794 M 1200 370 2
795 M 1264 405 2
796 M 1385 449 2
797 M 1515 391 2
798 M 1355 604 2

799 M 879 423 2
800 M 866 439 2
801 M 844 458 2
802 M 1398 565 2
803 M 1414 596 2
804 M 1414 618 2
805 M 1398 647 2
806 M 1314 673 2
807 M 1376 660 2
808 M 1368 691 2
809 M 1339 720 2
810 M 1160 637 2
811 M 1214 672 2
812 M 1257 700 2
813 M 1249 741 2
814 M 1305 750 2
815 M 1253 802 2
816 M 1128 863 2
817 M 1158 845 2
818 M 1168 841 2
819 M 831 618 2
820 M 876 573 2
821 M 816 534 2
822 M 808 702 2
823 M 538 515 2
824 M 694 731 2
825 M 756 580 2
826 M 437 290 2
827 M 387 243 2
828 M 316 198 2
829 M 440 214 2
830 M 399 137 2
831 M 406 413 2
832 M 379 404 2
833 M 366 434 2
834 M 393 451 2
835 M 314 522 2
836 M 277 598 2
837 M 355 589 2
838 M 325 604 2
839 M 285 624 2
840 M 511 470 2
841 M 570 442 2

842 M 422 549 2
843 M 402 509 2
844 M 326 574 2
845 M 232 574 2
846 M 491 508 2
847 M 476 486 2
848 M 522 483 2
849 M 189 692 2
850 M 162 705 2
851 M 315 654 2
852 M 342 663 2
853 M 383 658 2
854 M 407 654 2
855 M 420 646 2
856 M 442 641 2
857 M 307 635 2
858 M 369 593 2
859 M 266 673 2
860 M 224 732 2
861 M 154 790 2
862 M 110 814 2
863 M 245 709 2
864 M 236 679 2
865 M 415 594 2
866 M 383 658 2
867 M 503 597 2
868 M 509 460 2
869 M 275 768 2
870 M 226 803 2
871 M 185 828 2
872 M 218 846 2
873 M 145 883 2
874 M 309 643 2
875 M 292 645 2
876 M 359 685 2
877 M 387 614 2
878 M 427 646 2
879 M 288 648 2
880 M 299 658 2
881 M 392 581 2
882 M 327 554 2
883 M 330 639 2
884 M 325 643 2

885 M 327 637 2
886 M 283 628 2
887 M 338 668 2
888 M 402 659 2
889 M 337 661 2
890 M 317 600 2
891 M 382 613 2
892 M 340 649 2
893 M 349 557 2
894 M 353 694 2
895 M 320 616 2
896 M 376 640 2
897 M 372 562 2
898 M 351 598 2
899 M 492 496 2
900 M 414 545 2
901 M 494 392 2
902 M 367 492 2
903 M 407 527 2
904 M 371 510 2
905 M 357 409 2
906 M 359 518 2
907 M 501 445 2
908 M 356 382 2
909 M 332 489 2
910 M 376 535 2
911 M 328 386 2
912 M 341 452 2
913 M 328 470 2
914 M 440 524 2
915 M 317 457 2
916 M 327 397 2
917 M 524 443 2
918 M 490 351 2
919 M 419 537 2
920 M 330 482 2
921 M 320 401 2
922 M 334 462 2
923 M 539 421 2
924 M 336 513 2
925 M 448 526 2
926 M 435 536 2
927 M 312 449 2

928 M 369 520 2
929 M 329 480 2
930 M 504 379 2
931 M 466 540 2
932 M 357 512 2
933 M 484 505 2
934 M 346 523 2
935 M 371 360 2
936 M 433 346 2
937 M 524 466 2
938 M 500 358 2
939 M 530 447 2
940 M 482 501 2
941 M 320 441 2
942 M 506 445 2
943 M 519 384 2
944 S 1321 223 1
945 S 721 297 1
946 S 1091 592 1
947 S 584 551 1
948 S 544 683 1
949 S 356 623 1
950 S 426 442 1
ppmpp.hpp - 23814 bytes.
1 // MIT No Attribution
2 //
3 // ppmpp.hpp - A header-only class to draw/read/write 2D graphics using only the sta\
4 ndard library.
5 // Version 1.0 release (3:rd of December 2022).
6 // Copyright (c) 2022-2023 Håkan Blomqvist
7 //
8 // For more information:
9 // https://leanpub.com/2dcomputergraphicsinmoderncandstandardlibrary/
10 // https://gist.github.com/chbtoys/cdd6a85e321593ea0a1e7141d0a09fbc <- ppmpp.hpp
11 // https://gist.github.com/chbtoys/a665b52f86768b8e601c82b47ce18e49 <- test.cpp
12 //
13 // Permission is hereby granted, free of charge, to any person obtaining a copy of t\
14 his
15 // software and associated documentation files (the "Software"), to deal in the Soft\
16 ware
17 // without restriction, including without limitation the rights to use, copy, modify,
18 // merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
19 // permit persons to whom the Software is furnished to do so.
20 //
21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIE\
22 D,
23 // INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
24 // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
25 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
27 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28
30
33 #include <tuple>
34 #include <vector>
35 #include <random>
36 #include <cmath>
38
39 namespace ppm
40 {
41 // Typedef
42 typedef std::tuple<float, float, float> pixel;
43 typedef std::tuple<int, int, int, int> coord;
44 typedef std::tuple<int, int> point;
45
46 class image
47 {
48 public:
49 // Constructs an empty image.
50 image() {}
51
52 // Constructs an empty image of specified width and height.
53 image(int width, int height) {resize(width, height);}
54
55 // Constructs an image reading data from specified file
56 explicit image(std::string const& filename)
57 {
58 read(filename);
59 }
60
61 // Resizes the image pixel buffer.
62 void resize(int width, int height)
63 {
64 m_img.clear();
65 m_img.resize(width*height);
66 set_width(width);
67 set_height(height);
68 }
69
70 void set_width(int width)
71 {
72 m_width=width;
73 }
74
75 void set_height(int height)
76 {
77 m_height=height;
78 }
79
80 int get_width()
81 {
82 return m_width;
83 }
84
85 int get_height()
86 {
87 return m_height;
88 }
89
90 void set_pixel(int x, int y, pixel px)
91 {
92 m_img[x+m_width*y]=px;
93 }
94
95 pixel get_pixel(int x, int y)
96 {
97 return m_img[x+m_width*y];
98 }
99
100 void set_all_pixels(pixel px)
101 {
102 for (int y=0;y<m_height;++y)
103 {
104 for (int x=0;x<m_width;++x)
105 {
106 m_img[x+m_width*y]=px;
107 }
108 }
109 }
110
111 // Drawline
112 void draw_line(coord &coords, pixel &linecolor)
113 {
114 coord coords2;
115 if (clipline(coords,coords2)) {
116 drawline(coords2,linecolor);
117 }
118 }
119
120 // Get angled line
121 void get_angled_line(coord &coords, point &center, double degrees, int length)
122 {
124 coords=std::make_tuple(std::get<0>(center),std::get<1>(center),int(double(st
125 t<0>(center)) + cos(angle)*double(length)),int(double(std::get<1>(center)) + sin(ang
126 le)*double(length)));
127 }
128
129 // Draw Curves (requires C++20)
130 #if __cplusplus >= 202002L
131 void draw_bezier_quadratic(point pt0, point pt1, point pt2, int split, pixel bezie\
132 rcolor)
133 {
135 quadraticbeziercurves(pt0,pt1,pt2,split,xy);
136 // drawxydots(xy,beziercolor);
137 drawxyline(xy,beziercolor,pt2);
138 }
139
140 void draw_bezier_cubic(point pt0, point pt1, point pt2, point pt3, int split, pixe\
141 l beziercolor)
142 {
144 cubicbeziercurves(pt0,pt1,pt2,pt3,split,xy);
145 drawxyline(xy,beziercolor,pt3);
146 }
147 #endif
148
149 // Draw rectangles
150 void draw_rectangle(point &xy, point &wh, pixel &rectanglecolor)
151 {
152 drawrect(xy,wh,rectanglecolor);
153 }
154
155 void draw_filled_rectangle(point &xy, point &wh, pixel &rectanglecolor)
156 {
157 drawfilledrect(xy,wh,rectanglecolor);
158 }
159
160 // Draw Circles
161 void draw_circle(point &xy, int radius, pixel &circlecolor)
162 {
163 drawcircle(xy,radius,circlecolor);
164 }
165
166 void draw_filled_circle(point &xy, int radius, pixel &circlecolor)
167 {
168 drawfilledcircle(xy,radius,circlecolor);
169 }
170
171 // Draw Wedge
172 void draw_wedge(point center,int radius,int start_angle,int end_angle,pixel &wedge\
173 color)
174 {
175 drawwedge(center,radius,start_angle,end_angle,wedgecolor);
176 }
177
178 void draw_filled_wedge(point center,int radius,int start_angle,int end_angle,pixel\
179 &wedgecolor)
180 {
181 drawfilledwedge(center,radius,start_angle,end_angle,wedgecolor);
182 }
183
184 // Draw Triangles
185 void draw_triangle(point pt1, point pt2, point pt3, pixel &trianglecolor)
186 {
187 drawtriangle(pt1,pt2,pt3,trianglecolor);
188 }
189
190 void draw_filled_triangle(point pt1,point pt2,point pt3,pixel &color)
191 {
192 drawfilledtriangle(pt1,pt2,pt3,color);
193 }
194
195 // Blend Colors
196 pixel blend_colors(pixel &colorbackground, pixel &colorforeground, float alpha)
197 {
199 r = (std::get<0>(colorforeground) * alpha) + (std::get<0>(colorbackground) *
200 - alpha));
201 g = (std::get<1>(colorforeground) * alpha) + (std::get<1>(colorbackground) *
202 - alpha));
203 b = (std::get<2>(colorforeground) * alpha) + (std::get<2>(colorbackground) *
204 - alpha));
205
207 }
208
209 // Read PPM Image
210 void read(std::string const& filename)
211 {
212 std::string magic;
213 int max;
214 uint8_t buffer[3];
215 pixel color;
216
217 std::ifstream in(filename, std::ifstream::binary);
218
219 if (!in.is_open())
220 {
221 std::cout << "Can't open " << filename << std::endl;
222 exit(1);
223 }
224
225 in >> magic;
227 char c;
228 in.get(c);
229 if (c == '#')
230 {
231 // We got comments in the PPM image and skip the comments
232 while (c != '\n')

233 {
234 in.get(c);
235 }
236 }
237 else
238 {
239 in.seekg(-1, in.cur);
240 }
241
242 in >> m_width >> m_height >> max;
243
244 if (max != 255) {
245 std::cout << "Not 8 bit per rgb color." << std::endl;
246 exit(1);
247 }
248
249 if (magic == "P6")
250 {
251 // Move curser once to skip '\n'
253
254 m_img.clear();
255
256 for (int i = 0; i < m_width * m_height; ++i)
257 {
258 in.read(reinterpret_cast<char *>(buffer), 3);
259 color=std::make_tuple(float(float(buffer[0])/255.0),float(fl
260 0),float(float(buffer[2])/255.0));
261 m_img.push_back(color);
262 }
263 } else {
264 std::cout << filename << " is not a P6 file." << std::endl;
265 exit(1);
266 }
267
268 in.close();
269 }
270
271 // Write PPM image.
272 void write(std::string const& filename)
273 {
274 pixel color;

276 out << "P6" << std::endl << m_width << ' ' << m_height << std::endl << "255"
277 td::endl;
278
279 for (int i=0;i<(m_width*m_height);++i)
280 {
281 color=m_img[i];
282 out << char(std::get<0>(color)*255.0f) << char(std::get<1>(color)*25
283 r(std::get<2>(color)*255.0f);
284 }
285 out.close();
286 }
287
288 protected:
289 int getindex(int x, int y)
290 {
291 return x+m_width*y;
292 }
293
294 void drawline(coord &coords, pixel &color)
295 {
296 int x1=std::get<0>(coords); int y1=std::get<1>(coords); int x2=std::get<2>(c
297 ); int y2=std::get<3>(coords);
299 dx = x2 - x1; dy = y2 - y1;
300 if (dx == 0)
301 {
302 if (y2 < y1) std::swap(y1, y2);
303 for (y = y1; y <= y2; y++)
304 m_img[getindex(x1,y)]=color;
305 return;
306 }
307 if (dy == 0)
308 {
309 if (x2 < x1) std::swap(x1, x2);
310 for (x = x1; x <= x2; x++)
311 m_img[getindex(x,y1)]=color;
312 return;
313 }
315 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
316 if (dy1 <= dx1)
317 {
318 if (dx >= 0)

319 {
320 x = x1; y = y1; xe = x2;
321 }
322 else
323 {
324 x = x2; y = y2; xe = x1;
325 }
326 m_img[getindex(x,y)]=color;
327 for (i = 0; x<xe; i++)
328 {
329 x = x + 1;
330 if (px<0)
331 px = px + 2 * dy1;
332 else
333 {
334 if ((dx<0 && dy<0) || (dx>0 && dy>0)) y = y + 1; els
335 px = px + 2 * (dy1 - dx1);
336 }
338 }
339 }
340 else
341 {
342 if (dy >= 0)
343 {
344 x = x1; y = y1; ye = y2;
345 }
346 else
347 {
348 x = x2; y = y2; ye = y1;
349 }
351 for (i = 0; y<ye; i++)
352 {
353 y = y + 1;
354 if (py <= 0)
355 py = py + 2 * dx1;
356 else
357 {
358 if ((dx<0 && dy<0) || (dx>0 && dy>0)) x = x + 1; els
359 py = py + 2 * (dx1 - dy1);
360 }
362 }
363 }
364 }
365
366 int findregion(int x, int y, int width, int height)
367 {
368 int code=0;
369 if(y >= height)
370 code |= 1; //top
371 else if(y < 0)
373 if(x >= width)
375 else if (x < 0)
376 code |= 8; //left
377 return(code);
378 }
379
380 bool clipline(coord &coords1, coord &coords2)
381 {
382 int x1=std::get<0>(coords1); int y1=std::get<1>(coords1); int x2=std::get<2>
383 ds1); int y2=std::get<3>(coords1);
387 code1 = findregion(x1, y1, m_width, m_height); //the region outcodes for the
388 oints
389 code2 = findregion(x2, y2, m_width, m_height);
390 do //In theory, this can never end up in an infinite loop, it'll always come
391 ne of the trivial cases eventually
392 {
393 if(!(code1 | code2)) accept = done = 1; //accept because both endpo
394 screen or on the border, trivial accept
395 else if(code1 & code2) done = 1; //the line isn't visible on screen,
396 ect
398 {
399 int x, y;
402 {
403 x = x1 + (x2 - x1) * (m_height - y1) / (y2 - y1);
404 y = m_height - 1;
405 }
407 {
408 x = x1 + (x2 - x1) * -y1 / (y2 - y1);
409 y = 0;
410 }
412 {
413 y = y1 + (y2 - y1) * (m_width - x1) / (x2 - x1);
414 x = m_width - 1;
415 }
416 else //left
417 {
418 y = y1 + (y2 - y1) * -x1 / (x2 - x1);
419 x = 0;
420 }
422 {
423 x1 = x; y1 = y;
425 }
427 {
428 x2 = x; y2 = y;
430 }
431 }
432 }
434 if(accept)
435 {
436 x3 = x1;
437 x4 = x2;
438 y3 = y1;
439 y4 = y2;
441 return 1;
442 }
443 else
444 {
445 x3 = x4 = y3 = y4 = 0;
447 return 0;
448 }
449 }
450
452 void quadraticbeziercurves(point pt0, point pt1, point pt2, int split, std::vector\
453 <std::tuple<int,int>>& xy)
454 {
455 double t=0.0;
457 int x=0;
458 int y=0;
459 int x1=0;
460 int y1=0;
461 int x2=0;
462 int y2=0;
464 {
465 x1 = std::lerp(std::get<0>(pt0),std::get<0>(pt1),t);
466 y1 = std::lerp(std::get<1>(pt0),std::get<1>(pt1),t);
472 t+=delta;
473 }
474 }
475
476 void cubicbeziercurves(point pt0, point pt1, point pt2, point pt3, int split, std:\
477 :vector<std::tuple<int,int>>& xy)
478 {
479 float t=0.0;
481 int x=0;
482 int y=0;
483 int x1=0;
484 int y1=0;
485 int x2=0;
486 int y2=0;
487 int x3=0;
488 int y3=0;
489 int x4=0;
490 int y4=0;

491 int xx1=0;
492 int yy1=0;
493 int xx2=0;
494 int yy2=0;
496 {
501
506
511
515 t+=delta;
516 }
517 }
518 #endif
519
520 void drawxyline(std::vector<point> &xy, pixel &color, point stop)
521 {
522 point temp=xy[0];
523 point store;
524 store=std::make_tuple(std::get<0>(stop),std::get<1>(stop));
525 xy.push_back(store);
526 std::vector<coord> xyxy;
527 for (int i=1;i<xy.size();++i)
528 {
529 store=xy[i];
530 xyxy.push_back(std::make_tuple(std::get<0>(temp),std::get<1>(temp),s
531 tore),std::get<1>(store)));
532 temp=xy[i];
533 }
534
535 for (auto& li : xyxy)
536 {
537 draw_line(li,color);
538 }
539 }
540
541 void drawxydots(std::vector<point> &xy, pixel &color)
542 {
544 {
545 m_img[getindex(std::get<0>(pt),std::get<1>(pt))]=color;
546 }
547 }
548
549 void drawrect(point &xy, point &wh, pixel &color)
550 {
551 int x=std::get<0>(xy);int y=std::get<1>(xy);int w=std::get<0>(wh);int h=std:
552 1>(wh);
553 coord coords=std::make_tuple(x, y, x+w, y);
554 draw_line(coords, color);
555 coords=std::make_tuple(x+w, y, x+w, y+h);
557 coords=std::make_tuple(x+w, y+h, x, y+h);
559 coords=std::make_tuple(x, y+h, x, y);
561 }
562
563 void drawfilledrect(point &xy, point &wh, pixel &color)
564 {
565 int x2 = std::get<0>(xy) + std::get<0>(wh);
566 int y2 = std::get<1>(xy) + std::get<1>(wh);
567
568 coord coords=std::make_tuple(0,0,0,0);
569 for (int i = std::get<1>(xy); i < y2; ++i)
570 {
571 coords=std::make_tuple(std::get<0>(xy),i,x2,i);
573 }
574 }
575
576 void drawcircle(point &xy, int radius, pixel &color)

577 {
578 int x0 = 0;
580 int d = 3 - 2 * radius;
581 int xx=0;
582 int yy=0;
583 int x=std::get<0>(xy);
584 int y=std::get<1>(xy);
588
589 while (y0 >= x0)
590 {
591 if (mask & 0x01) {xx=x + x0;yy=y - y0;coords=std::make_tuple(xx,yy,x
592 ine(coords, color);}
593 if (mask & 0x02) {xx=x + y0;yy=y - x0;coords=std::make_tuple(xx,yy,x
595 if (mask & 0x04) {xx=x + y0;yy=y + x0;coords=std::make_tuple(xx,yy,x
597 if (mask & 0x08) {xx=x + x0;yy=y + y0;coords=std::make_tuple(xx,yy,x
599 if (mask & 0x10) {xx=x - x0;yy=y + y0;coords=std::make_tuple(xx,yy,x
601 if (mask & 0x20) {xx=x - y0;yy=y + x0;coords=std::make_tuple(xx,yy,x
603 if (mask & 0x40) {xx=x - y0;yy=y - x0;coords=std::make_tuple(xx,yy,x
605 if (mask & 0x80) {xx=x - x0;yy=y - y0;coords=std::make_tuple(xx,yy,x
607 if (d < 0) d += 4 * x0++ + 6;
608 else d += 4 * (x0++ - y0--) + 10;
609 }
610 }
611
612 void drawfilledcircle(point &xy, int radius, pixel &color)
613 {
614 int x0 = 0;
616 int d = 3 - 2 * radius;
617 int x=std::get<0>(xy);
618 int y=std::get<1>(xy);

621
622 while (y0 >= x0)
623 {
624 coords=std::make_tuple(x-x0,y-y0,x+x0,y-y0);
626 coords=std::make_tuple(x-y0,y-x0,x+y0,y-x0);
628 coords=std::make_tuple(x-x0,y+y0,x+x0,y+y0);
630 coords=std::make_tuple(x-y0,y+x0,x+y0,y+x0);
632 if (d < 0) d += 4 * x0++ + 6;
633 else d += 4 * (x0++ - y0--) + 10;
634 }
635 }
636
637 void getallys(std::vector<int> &ys,std::vector<point> &coords)
638 {
641 }
642
645 }
646
647 void getlinecoords(coord line,std::vector<point> &coords)
648 {
650 int x1=std::get<0>(line);int y1=std::get<1>(line);int x2=std::get<2>(line);i
651 =std::get<3>(line);
652 dx = x2 - x1; dy = y2 - y1;
653 if (dx == 0)
654 {
655 if (y2 < y1) std::swap(y1, y2);
656 for (y = y1; y <= y2; y++)
658 return;
659 }
660 if (dy == 0)
661 {
662 if (x2 < x1) std::swap(x1, x2);

663 for (x = x1; x <= x2; x++)
665 return;
666 }
668 px = 2 * dy1 - dx1; py = 2 * dx1 - dy1;
669 if (dy1 <= dx1)
670 {
671 if (dx >= 0)
672 {
673 x = x1; y = y1; xe = x2;
674 }
675 else
676 {
677 x = x2; y = y2; xe = x1;
678 }
680 for (i = 0; x<xe; i++)
681 {
682 x = x + 1;
683 if (px<0)
684 px = px + 2 * dy1;
685 else
686 {
687 if ((dx<0 && dy<0) || (dx>0 && dy>0)) y = y + 1; els
688 px = px + 2 * (dy1 - dx1);
689 }
691 }
692 }
693 else
694 {
695 if (dy >= 0)
696 {
697 x = x1; y = y1; ye = y2;
698 }
699 else
700 {
701 x = x2; y = y2; ye = y1;
702 }
704 for (i = 0; y<ye; i++)
705 {
706 y = y + 1;
707 if (py <= 0)
708 py = py + 2 * dx1;
709 else
710 {
711 if ((dx<0 && dy<0) || (dx>0 && dy>0)) x = x + 1; els
712 py = py + 2 * (dx1 - dy1);
713 }
715 }
716 }
717 }
718
719 void drawwedge(point center,int radius,int start_angle,int end_angle,pixel &color)
720 {
721 std::vector<point> coords;
722
723 float angle=(((start_angle<=end_angle)?start_angle:end_angle)*(M_PI/180));
724 float range=(((end_angle>start_angle)?end_angle:start_angle)*(M_PI/180));
725 float x=(radius*cos(angle));
726 float y=(radius*sin(angle));
727 do
728 {
729 coords.push_back(std::make_tuple((int)(std::get<0>(center)+x+0.5),(i
730 <1>(center)-y+0.5)));
731 angle+=0.001;
732 x=(radius*cos(angle));
733 y=(radius*sin(angle));
734 }
735 while(angle<=range);
736
737 point co1=coords.front();
738 point co2=coords.back();
739
740 coord line1=std::make_tuple(std::get<0>(center),std::get<1>(center),std::get
741 o1),std::get<1>(co1));
743 o2),std::get<1>(co2));
744
745 getlinecoords(line1,coords);
747
748 for (auto & e : coords)

749 {
750 line1=std::make_tuple(std::get<0>(e),std::get<1>(e),std::get<0>(e),s
751 ));
752 draw_line(line1,color);
753 }
754 }
755
756 void drawfilledwedge(point center,int radius,int start_angle,int end_angle,pixel &\
757 color)
758 {
759 std::vector<point> coords;
760
761 float angle=(((start_angle<=end_angle)?start_angle:end_angle)*(M_PI/180));
762 float range=(((end_angle>start_angle)?end_angle:start_angle)*(M_PI/180));
763 float x=(radius*cos(angle));
764 float y=(radius*sin(angle));
765 do
766 {
767 coords.push_back(std::make_tuple((int)(std::get<0>(center)+x+0.5),(i
768 <1>(center)-y+0.5)));
769 angle+=0.001;
770 x=(radius*cos(angle));
771 y=(radius*sin(angle));
772 }
773 while(angle<=range);
774
775 point co1=coords.front();
776 point co2=coords.back();
777
779 o1),std::get<1>(co1));
781 o2),std::get<1>(co2));
782
785
788 getallys(ys,coords);
789 std::vector<coord> lines;
790

792 {
796 }
797 }
799 lines.push_back(std::make_tuple(xs.front(),ys[search],xs.back(),ys[s
800 xs.clear();
801 }
802
803 coord cd=std::make_tuple(0,0,0,0);
805 draw_line(l,color);
806 }
807 }
808
809 void drawtriangle(point pt1, point pt2, point pt3, pixel &color)
810 {
811 coord coords=std::make_tuple(std::get<0>(pt1),std::get<1>(pt1),std::get<0>(p
812 td::get<1>(pt2));
813 draw_line(coords,color);
814 coords=std::make_tuple(std::get<0>(pt2),std::get<1>(pt2),std::get<0>(pt3),st
815 t<1>(pt3));
817 coords=std::make_tuple(std::get<0>(pt3),std::get<1>(pt3),std::get<0>(pt1),st
818 t<1>(pt1));
820 }
821
822 void drawfilledtriangle(point pt1,point pt2,point pt3,pixel &color)
823 {
824 int x1=std::get<0>(pt1); int y1=std::get<1>(pt1); int x2=std::get<0>(pt2); i
825 =std::get<1>(pt2); int x3=std::get<0>(pt3); int y3=std::get<1>(pt3);
828
833 int e1, e2;

837
838 t1x = t2x = x1; y = y1;
841 dy1 = (int)(y2 - y1);
842
845 dy2 = (int)(y3 - y1);
846
847 if (dy1 > dx1) {
848 SWAP(dx1, dy1);
850 }
851 if (dy2 > dx2) {
852 SWAP(dy2, dx2);
854 }
855
856 e2 = (int)(dx2 >> 1);
858 e1 = (int)(dx1 >> 1);
859
860 for (int i = 0; i < dx1;) {
861 t1xp = 0; t2xp = 0;
864 while (i<dx1) {
865 i++;
866 e1 += dy1;
867 while (e1 >= dx1) {
868 e1 -= dx1;
871 }
874 }
875 next1:
876 while (1) {
877 e2 += dy2;
878 while (e2 >= dx2) {
879 e2 -= dx2;
882 }
885 }
886 next2:
891 coords=std::make_tuple(minx,y,maxx,y);
894 t1x += t1xp;
896 t2x += t2xp;
897 y += 1;
898 if (y == y2) break;
899
900 }
901 next:
904 dy1 = (int)(y3 - y2);
905 t1x = x2;
906
907 if (dy1 > dx1) {
908 SWAP(dy1, dx1);
910 }
912
913 e1 = (int)(dx1 >> 1);
914
915 for (int i = 0; i <= dx1; i++) {
916 t1xp = 0; t2xp = 0;
919 while (i<dx1) {
920 e1 += dy1;
921 while (e1 >= dx1) {
922 e1 -= dx1;
925 }
928 if (i<dx1) i++;
929 }
930 next3:
931 while (t2x != x3) {
932 e2 += dy2;
933 while (e2 >= dx2) {
934 e2 -= dx2;
937 }
940 }
941 next4:
942
947 coords=std::make_tuple(minx,y,maxx,y);
950 t1x += t1xp;
952 t2x += t2xp;
953 y += 1;
955 }
956 }
957
958 std::vector<pixel> m_img;
959 int m_width;
960 int m_height;
961 };
962
963 } // namespace ppm
test.cpp - 2521 bytes.
1 // Compile: clang++ -std=c++17 test.cpp -o test

2 // Compile: clang++ -std=c++20 test.cpp -o test
3
4 // Tests of ppmpp.hpp
5
6 #include <tuple>
7 #include "ppmpp.hpp"
8
9 int main()
10 {
11 ppm::image image("test.ppm");
12 image.write("test_copy.ppm");
13 std::cout << image.get_width() << " " << image.get_height() << std::endl;
14 ppm::pixel color=std::make_tuple(0.0f,0.0f,0.0f);
15 ppm::pixel color2=std::make_tuple(0.0f,1.0f,1.0f);
16 ppm::image image2(1920,1080);
17 std::cout << image2.get_width() << " " << image2.get_height() << std::endl;
18 // image2.set_all_pixels(color2);
19 for (int y=0;y<image2.get_height();++y)
20 {
21 for (int x=0;x<image2.get_width();++x)
22 {
23 image2.set_pixel(x,y,color2);
24 }
25 }
26 ppm::point pt0;ppm::point pt1;ppm::point pt2;ppm::point pt3;
27 ppm::coord coords=std::make_tuple(10,300,700,900);
28 ppm::point center=std::make_tuple(1920/2,1080/2);
29 image2.draw_line(coords,color);
30 image2.get_angled_line(coords,center,7,300);
31 image2.draw_line(coords,color);
32 // Lerp requires C++20.
34 pt0=std::make_tuple(340,90);
38 image2.draw_bezier_quadratic(pt0,pt1,pt2,50,color);
43 image2.draw_bezier_cubic(pt0,pt1,pt2,pt3,50,color);
44 #endif
45 ppm::point ptxy=std::make_tuple(500,500);
46 ppm::point ptwh=std::make_tuple(900,200);
47 image2.draw_rectangle(ptxy,ptwh,color);
48 ptxy=std::make_tuple(100,100);
49 ptwh=std::make_tuple(900,200);
50 image2.draw_filled_rectangle(ptxy,ptwh,color);
52 image2.draw_circle(ptxy,250,color);
54 image2.draw_filled_circle(ptxy,250,color);
57 ppm::pixel color3=image2.blend_colors(color4,color5,0.5f);
59 ptwh=std::make_tuple(100,100);
60 image2.draw_filled_rectangle(ptxy,ptwh,color3);
61 ppm::point pt=std::make_tuple(400,400);
62 image2.draw_wedge(pt,150,0,45,color3);
63 pt=std::make_tuple(800,800);
64 image2.draw_filled_wedge(pt,150,0,45,color5);
68 image2.draw_triangle(pt1,pt2,pt3,color5);
72 image2.draw_filled_triangle(pt1,pt2,pt3,color5);
73 image2.write("test2.ppm");
74
75 return 0;
76 }

2d Computer Graphics in Modern C and Standard Library Compress

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

2d Computer Graphics in Modern C and Standard Library Compress

Uploaded by

Copyright:

Available Formats

2D Computer Graphics in modern c++ and

This version was published on 2023-05-14

© 2023 Håkan Blomqvist

2 Draw Pixels with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 Texture Generation with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4 Time to draw some lines with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . 11

5 There are no straight curves, only curved lines . . . . . . . . . . . . . . . . . . . . . . . . . . 19

6 Rectangles with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

7 Circles with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

8 Triangles with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

9 Animation with Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

10 Drawing Charts and a Font . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

11 Presentation, Collaboration, and Investigation . . . . . . . . . . . . . . . . . . . . . . . . . . 36

12 PPM++ header-only library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

13 In the Rearview Mirror . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

14 Appendix A: Source Code Listings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

1.2 Standard Library

1.3 Compile Code Examples

1 P3 # "P3" means this is a RGB color image in ASCII

Greyscale = (0.2126R) + (0.7152G) + (0.0722*B);

RGB => GRB

RGB => BGR

RGB => RRB

But, now, let’s draw some lines.

• Linear Bézier curves

Here we have a rectangle and a filled rectangle.

Here we have a circle and a filled circle.

For the source code, take a look in Appendix A: 12_circles_from_file.cpp

Another example of reading data and rendering an image.

Here we have a triangle and a filled triangled

Also as a P6 PPM as it has the same width and height as 15_radarchart.ppm.

To draw each letter in the font, take a look in Appendix A: 15_draw_font.cpp

11.2 Draw a bar chart

Drawing a bar chart, take a look in Appendix A: 16_draw_bar_chart.cpp

11.3 Draw a pie chart

Pie chart in PPM, take a look in Appendix A: 16_draw_pie_chart.cpp

11.4 Draw a donut chart

Pie chart in PPM, take a look in Appendix A: 16_draw_donut_chart.cpp

11.5 Draw a table

Pie chart in PPM, take a look in Appendix A: 16_draw_table.cpp.cpp

11.6 Draw a more advanced chart 1

Step #1: 16_draw_market_size1.ppm

The ‘generate_linear_gradient_image’ function creates a linear gradient image by blending two

Step #2: 16_draw_market_size2.ppm

Step #3: 16_draw_market_size3.ppm

‘generate_radial_gradient_image’ generates a radial gradient image using two input colors. It

Step #4: 16_draw_market_size4.ppm

‘generate_repeating_texture_image’ generates a repeating texture image using an input color. The

Step #5: 16_draw_market_size5.ppm

‘render_repeating_texture_image’ renders a repeating texture image by tiling a smaller texture

Step #6: 16_draw_market_size6.ppm

Step #7: 16_draw_market_size7.ppm

Step #8: 16_draw_market_size8.ppm

Step #9: 16_draw_market_size9.ppm

Step #10: 16_draw_market_size10.ppm

Step #11: 16_draw_market_size11.ppm

Step #12: 16_draw_market_size12.ppm

The ‘add_white_hexagon_border’ function is designed to add a white border to an image based

Step #13: 16_draw_market_size13.ppm

Step #14: 16_draw_market_size14.ppm

Step #15: 16_draw_market_size15.ppm

Pie chart in PPM, take a look in Appendix A: 16_draw_market_size.cpp

11.7 Draw a more advanced chart 2