# Preface

The previous "article" wrote how I made the first picture of the article. Some visitors recommended using Figma, but I looked around, it was so complicated, or PPT Simple 😂, so I want to directly generate a ppt with the background and basic text in the background every time I write an article. I directly download it and change the text and add pictures to make the first picture, but I am not sure about the operation. I am not familiar with the encoding of ppt, what should I do?

Please go to ChatGPT here! 90% of the code of this function module is written by ChatGPT, including comments, I only modified some parts to adapt to my blog background.

# How do I do it?

My needs here are quite simple. After running, a PPT file with a gradient background is generated, which includes two text boxes, one is the site name at the bottom, and the other is the reserved article title.

Of course, we can't ask ChatGPT directly. It currently can't understand too broad and vague instructions. You can only guide it step by step to generate code according to your requirements.

First I let it generate an image with a beveled gradient:

Then let it add a photo to the ppt and set it to full screen:

Then let it write a piece of code to generate ppt, and let him add some text to this ppt:

In the end, we humans need to take the lead, integrate these code fragments together, debug, and finally deliver them for use.

# Epilogue

I think this kind of programming experience is really amazing. Although the given code is not 100% directly usable, we manually correct the error or tell it to let it fix the error and give the correct answer. If interested, read on for the full code with this functionality.

Although time will make people lose interest in learning basic knowledge, but since I already have a lighter, why should I drill wood to make fire, right?

# Complete demo

You need to install the following two packages to run this demo.

pip3 install Pillow
pip3 install python-pptx

from PIL import Image
import random
from pptx import Presentation
from pptx.enum.shapes import MSO_SHAPE
from pptx.util import Inches,Pt
from pptx.dml.color import RGBColor
import os
# centimeters to inches
def cm_to_in(cm):
     return Inches(cm / 2.54)
# Some gradient color combinations
data = [((189,195,199),(44,62,80)),
         ((121,159,12),(172,187,120)),
         ((51,77,80),(203,202,165)),
         ((247,248,248),(172,187,120)),
         ((255,224,0),(121,159,12)),
         ((0,65,106),(228,229,230))]

random_index = random.randrange(len(data)) # generate a random index

# Get the gradient color combination according to the random index
random_data = data[random_index]

def gradient_color(start_color, end_color, step):
     """
     Generate step gradient colors from start_color to end_color
     """
     start_r, start_g, start_b = start_color
     end_r, end_g, end_b = end_color
     r_step = (end_r - start_r) / step
     g_step = (end_g - start_g) / step
     b_step = (end_b - start_b) / step

     colors = []
     for i in range(step):
         r = int(start_r + i * r_step)
         g = int(start_g + i * g_step)
         b = int(start_b + i * b_step)
         colors. append((r, g, b))
     return colors

def create_gradient_image(width, height, colors):
     """
     Create gradient images
     """
     img = Image.new('RGB', (width, height))
     data = []
     for y in range(height):
         for x in range(width):
             # Calculate the corresponding color according to the position of the pixel
             ratio = (x + y) / (width + height)
             color_index = int(ratio * (len(colors) - 1))
             color = colors[color_index]
             data.append(color)
     # write data to image
     img. putdata(data)

     return img

if __name__ == '__main__':
     # Gradient start and end colors
     start_color = random_data[0] # red
     end_color = random_data[1] # green
     # generate 256 gradient colors
     step = 256
     colors = gradient_color(start_color, end_color, step)
     # Create a gradient image
     width, height = 1920, 1080
     img = create_gradient_image(width, height, colors)
     # save Picture
     img.save('gradient.png')

     prs=Presentation()
     # Set the Slide aspect ratio to 16:9
     prs. slide_height = int(720/96 * 914400)
     prs. slide_width = int(1280/96 * 914400)
     blank_slide_layout=prs.slide_layouts[6]
     slide=prs.slides.add_slide(blank_slide_layout)
     slide.shapes.add_picture('gradient.png', 0, 0, prs.slide_width, prs.slide_height)
     #Set the position of the text box to be created
     left = top = width = height = Inches(1)
     # instantiate a textbox
     txBox = slide.shapes.add_textbox(cm_to_in(14.76), cm_to_in(16.74), width, height)
     #Set the type of the text box
     tf=txBox.text_frame
     p = tf.add_paragraph()
     p.text="tstrs.me"
     #Set the font size of the newly added paragraph text to 40
     p.font.color.rgb = RGBColor(255, 255, 255) # font color
     p.font.name = 'Isoline' # font name
     p.font.size=Pt(32) # font size
     #Instantiate another textbox
     titletxBox = slide.shapes.add_textbox(cm_to_in(4.9), cm_to_in(4.27), width, height)
     #Set the type of the text box
     titletf=titletxBox.text_frame
     title = titletf.add_paragraph()
     title.text="Test Title"
     title.font.bold = True # set bold
     title.font.color.rgb = RGBColor(255, 255, 255) # font color
     title.font.name = 'Isoline' # font name
     title.font.size=Pt(80) # font size
     current_dir = os.path.dirname(os.path.abspath(__file__))
     pptx_filename = os.path.join(current_dir, "example.pptx")
     prs. save(pptx_filename)
     os. remove('gradient.png')
     print(f"Saved PPTX file: {pptx_filename}")