Hur använder man Pillow i en multiprocessmiljö?

Hej där! Jag är leverantör av Pillow och idag ska jag dela med mig av några tips om hur man använder Pillow i en miljö med flera processer.

Först och främst, låt oss förstå varför vi kanske vill använda Pillow i en flerprocessinstallation. Pillow är ett fantastiskt Python-bibliotek för bildbehandling. Men när du har att göra med ett stort antal bilder eller komplexa bildbehandlingsuppgifter, kan en engångsprocess vara väldigt långsam. Det är där multi-bearbetning kommer in. Den låter dig dela upp arbetet över flera CPU-kärnor, vilket påskyndar den totala bearbetningstiden.

Förutsättningar

Innan vi dyker in i detaljerna, se till att du har Pillow installerad. Du kan installera den med pip:

pip installera kudde

Du måste också ha en grundläggande förståelse för Pythonsmultibearbetningmodul. Denna modul ger ett enkelt sätt att köra flera processer i Python.

Grundläggande inställning

Låt oss börja med ett enkelt exempel. Anta att du har ett gäng bilder i en katalog och att du vill ändra storlek på dem alla. Så här kan du göra det med multi-processing och Pillow.

importera OS från PIL import Bildimport multiprocessing def resize_image(image_path): prova: med Image.open(image_path) som img: new_size = (img.width // 2, img.height // 2) resized_img = img.resize(new_size) output_path = os.path.join('resized_path)name os.image_path)name resized_img.save(output_path) förutom Undantag som e: print(f"Fel vid bearbetning av {image_path}: {e}") if __name__ == '__main__': image_dir = 'images' image_files = [os.path.join(image_dir, f) för f i os.listdir(image_dir,('ends.png') if 'f.jpg' '.jpeg'))] om inte os.path.exists('resized'): os.makedirs('resized') pool = multiprocessing.Pool(processes=multiprocessing.cpu_count()) pool.map(resize_image, image_files) pool.close() pool.join() print("Alla bilder har ändrats storleken framgångsrikt).

I den här koden definierar vi först en funktionresize_imagesom tar en bildsökväg, öppnar bilden med Pillow, ändrar storlek på den och sparar den ändrade bilden i en ny katalog. Sedan, iom __namn__ == '__main__'block, får vi en lista över alla bildfiler ibilderkatalog. Vi skapar en ny katalog som heterändra storlekför att lagra de ändrade storleksbilderna.

Vi skapar sedan enmultiprocessing.Poolobjekt med antalet processer lika med antalet tillgängliga CPU-kärnor. Depool.kartafunktionen tillämparresize_imagefunktion för varje bildfil i listan. Slutligen stänger vi poolen och väntar på att alla processer är färdiga att användapool.close()ochpool.join().

Dela resurser

En av utmaningarna i en miljö med flera processer är att dela resurser. Till exempel om du vill använda en enda kuddeBildobjekt över flera processer måste du vara försiktig.

Python'smultibearbetningmodulen har olika sätt att dela data mellan processer. Ett vanligt sätt är att använda delat minne. Men när det kommer till kuddbilder är det vanligtvis bättre att skicka bildvägarna mellan processerna och öppna bilderna separat i varje process. Detta beror på att Pillow-bilder inte är lätta att serialisera, vilket innebär att de inte enkelt kan delas mellan processer.

Felhantering

När du arbetar i en multiprocessmiljö blir felhanteringen ännu viktigare. Om en process misslyckas bör den inte ta ner hela operationen. I exemplet ovan lade vi till ett försök - utom block iresize_imagefunktion för att fånga upp eventuella undantag som kan inträffa under bildbehandling.

17335628263059f54c4f920cf28f75e407089c30353d6 20250331085854

Prestandaöverväganden

Även om multibearbetning kan påskynda bildbehandlingen avsevärt, är det inte alltid den bästa lösningen. Det finns en overhead förknippad med att skapa och hantera flera processer. Så om du har att göra med ett litet antal bilder eller enkla uppgifter, kan en engångsprocess vara snabbare.

Se också till att du inte överbelasta ditt system genom att skapa för många processer. I exemplet ovan använde vimultiprocessing.cpu_count()för att bestämma antalet processer. Detta är en bra utgångspunkt, men du kan behöva justera den baserat på dina specifika system- och uppgiftskrav.

Användningsfall i vår verksamhet

Som kuddleverantör använder vi flerprocessbildbehandling på flera sätt. Till exempel när vi får en stor order påKuddfodral, måste vi bearbeta produktbilder för vår webbplats. Vi använder multibearbetning för att snabbt ändra storlek, beskära och lägga till vattenstämplar till dessa bilder.

Ett annat användningsfall är när vi arbetar med nyaKuddemönster. Vi kan behöva generera flera varianter av samma design, och multi-processing hjälper oss att göra detta i rätt tid.

Vi använder också multi-processing för kvalitetskontroll. Vi kan bearbeta bilder på de färdiga produkterna för att kontrollera eventuella defekter. Vi kan till exempel använda Pillow för att upptäcka om sömmen på ett kuddfodral är rak eller om det finns fläckar på kudden.

Slutsats

Att använda Pillow i en miljö med flera processer kan vara ett kraftfullt sätt att påskynda bildbehandlingsuppgifter. Genom att dela upp arbetet över flera CPU-kärnor kan du hantera stora volymer bilder mer effektivt. Det är dock viktigt att överväga omkostnaderna för multibearbetning och hantera fel korrekt.

Om du är ute efter hög kvalitetKuddeprodukter eller behöver hjälp med bildbehandling för ditt företag, tveka inte att höra av dig. Vi är här för att hjälpa dig med alla dina kuddrelaterade behov och kan ge dig de bästa lösningarna för dina bildbehandlingsbehov. Oavsett om du är ett litet företag eller ett stort företag har vi expertis och resurser för att möta dina behov.