Pygame 1.9 - transform

pygame.transform




pygame

pygame.transform

सतहों को बदलने के लिए pygame मॉड्यूल

सर्फेस ट्रांसफॉर्म एक ऑपरेशन है जो पिक्सल्स को स्थानांतरित या आकार देता है। इन सभी कार्यों को संचालित करने के लिए एक सरफेस लेते हैं और परिणामों के साथ एक नया सरफेस लौटाते हैं।

कुछ परिवर्तनों को विनाशकारी माना जाता है। इसका मतलब है कि हर बार जब वे प्रदर्शन करते हैं तो वे पिक्सेल डेटा खो देते हैं। इसके सामान्य उदाहरण आकार बदलने और घूमने वाले हैं। इस कारण से, किसी छवि को कई बार बदलते रहने की तुलना में मूल सतह को फिर से बदलना बेहतर है। (उदाहरण के लिए, मान लीजिए कि आप उछलते हुए झरने को देख रहे हैं, जो फैलता है और सिकुड़ता है। यदि आपने पिछली छवियों में आकार में परिवर्तन को लागू किया है, तो आप विस्तार खो देंगे। इसके बजाय, हमेशा मूल छवि और इच्छित आकार के पैमाने से शुरू करें।

pygame.transform.flip(Surface, xbool, ybool) -> Surface

लंबवत और क्षैतिज रूप से पलटें

यह एक सतह को लंबवत, क्षैतिज रूप से, या दोनों में फ्लिप कर सकता है। एक सतह को फ़्लिप करना गैर-विनाशकारी है और समान आयामों के साथ एक नया सरफेस लौटाता है।

pygame.transform.scale(Surface, (width, height), DestSurface = None) -> Surface

नए संकल्प का आकार

एक नए रिज़ॉल्यूशन के लिए सरफेस का आकार बदलता है। यह एक तेज़ स्केल ऑपरेशन है जो परिणामों का नमूना नहीं देता है।

वैकल्पिक गंतव्य सतह का उपयोग किया जा सकता है, बजाय इसके कि यह एक नया निर्माण करे। यदि आप किसी चीज को बार-बार मापना चाहते हैं तो यह जल्दी होता है। हालाँकि, गंतव्य का आकार (चौड़ाई, ऊँचाई) समान होना चाहिए। साथ ही गंतव्य की सतह समान प्रारूप होनी चाहिए।

pygame.transform.rotate(Surface, angle) -> Surface

एक छवि घुमाएं

अनफिल्टर्ड वामावर्त रोटेशन। कोण तर्क डिग्री का प्रतिनिधित्व करता है और किसी भी अस्थायी बिंदु मान हो सकता है। नकारात्मक कोण राशियाँ दक्षिणावर्त घूमेंगी।

जब तक 90 डिग्री वेतन वृद्धि से घूर्णन नहीं होता, तब तक नए आकार को धारण करने के लिए छवि को बड़ा आकार दिया जाएगा। यदि छवि में पिक्सेल अल्फ़ाज़ हैं, तो गद्देदार क्षेत्र पारदर्शी होगा। अन्यथा pygame एक रंग चुन लेगा जो सर्फेस कॉलोर्के या टॉपलेट पिक्सेल मान से मेल खाता है।

pygame.transform.rotozoom(Surface, angle, scale) -> Surface

फ़िल्टर्ड स्केल और रोटेशन

यह एक संयुक्त पैमाना और रोटेशन परिवर्तन है। परिणामस्वरूप सतह एक फ़िल्टर की गई 32-बिट सतह होगी। स्केल तर्क एक अस्थायी बिंदु मान है जिसे वर्तमान रिज़ॉल्यूशन से गुणा किया जाएगा। कोण तर्क एक अस्थायी बिंदु मान है जो घूमने के लिए वामावर्त डिग्री का प्रतिनिधित्व करता है। एक नकारात्मक रोटेशन कोण दक्षिणावर्त घुमाएगा।

pygame.transform.scale2x(Surface, DestSurface = None) -> Surface

विशेष छवि दोगुनी

यह एक नई छवि लौटाएगा जो मूल के आकार से दोगुना है। यह AdvanceMAME Scale2X एल्गोरिथ्म का उपयोग करता है जो बिटमैप ग्राफ़िक्स के 'jaggie-less' पैमाने को करता है।

यह वास्तव में केवल ठोस रंगों के साथ सरल छवियों पर प्रभाव डालता है। फोटोग्राफिक और एंटीअलियासिड छवियों पर यह एक नियमित अनफ़िल्टर्ड पैमाने की तरह दिखेगा।

वैकल्पिक गंतव्य सतह का उपयोग किया जा सकता है, बजाय इसके कि यह एक नया निर्माण करे। यदि आप किसी चीज को बार-बार मापना चाहते हैं तो यह जल्दी होता है। हालाँकि गंतव्य की सतह सतह के आकार से दुगुनी होनी चाहिए। गंतव्य की सतह भी एक ही प्रारूप होनी चाहिए।

pygame.transform.smoothscale(Surface, (width, height), DestSurface = None) -> Surface

सतह को एक मनमाने आकार से सुचारू रूप से मापता है

आवश्यकतानुसार इनपुट सतह के प्रत्येक आयाम को स्केल करने के लिए दो अलग-अलग एल्गोरिदम में से एक का उपयोग करता है। संकोचन के लिए, आउटपुट पिक्सेल उन रंगों के क्षेत्र औसत होते हैं जिन्हें वे कवर करते हैं। विस्तार के लिए, एक बिलिनियर फ़िल्टर का उपयोग किया जाता है। X86-64 और i686 आर्किटेक्चर के लिए, अनुकूलित MMX रूटीन शामिल हैं और अन्य मशीन प्रकारों की तुलना में बहुत तेजी से चलेंगे। आकार (चौड़ाई, ऊंचाई) के लिए 2 नंबर अनुक्रम है। यह फ़ंक्शन केवल 24-बिट या 32-बिट सतहों के लिए काम करता है। यदि इनपुट सतह की गहराई 24 से कम है, तो एक अपवाद फेंक दिया जाएगा।

Pygame 1.8 में नया

pygame.transform.get_smoothscale_backend() -> String

उपयोग में स्मूथस्केल फ़िल्टर संस्करण लौटाएँ: 'जेनरिक', 'एमएमएक्स', या 'एसएसई'

यह दिखाता है कि स्मूथसेल MMX या SSE त्वरण का उपयोग कर रहा है या नहीं। यदि कोई त्वरण उपलब्ध नहीं है, तो "GENERIC" लौटाया जाता है। X86 प्रोसेसर के लिए उपयोग करने के लिए त्वरण का स्तर रनटाइम पर निर्धारित किया जाता है।

यह फ़ंक्शन pygame परीक्षण और डीबगिंग के लिए प्रदान किया गया है।

pygame.transform.set_smoothscale_backend(type) -> None

इसमें से एक के लिए smoothscale फ़िल्टर संस्करण सेट करें: 'GENERIC', 'MMX', या 'SSE'

Smoothscale त्वरण सेट करता है। एक स्ट्रिंग तर्क लेता है। 'सामान्य' का मान त्वरण को बंद कर देता है। 'एमएमएक्स' MMX निर्देशों का ही उपयोग करता है। 'SSE' SSE एक्सटेंशन की भी अनुमति देता है। यदि वर्तमान प्रोसेसर द्वारा प्रकार को मान्यता नहीं दी गई है या समर्थित नहीं है, तो मान त्रुटि को उठाया जाता है।

यह फ़ंक्शन pygame परीक्षण और डीबगिंग के लिए प्रदान किया गया है। यदि smoothscale एक अवैध अनुदेश त्रुटि का कारण बनता है तो यह एक pygame / SDL बग है जिसे रिपोर्ट किया जाना चाहिए। इस फ़ंक्शन का उपयोग केवल अस्थायी सुधार के रूप में करें।

pygame.transform.chop(Surface, rect) -> Surface

हटाए गए इंटीरियर क्षेत्र के साथ एक छवि की एक प्रति मिलती है

एक छवि का एक हिस्सा निकालता है। दिए गए आयत क्षेत्र के आसपास के सभी ऊर्ध्वाधर और क्षैतिज पिक्सेल हटा दिए गए हैं। कोने क्षेत्रों (आयताकार के लिए विकर्ण) को फिर एक साथ लाया जाता है। (इस ऑपरेशन से मूल छवि नहीं बदली गई है।)

NOTE : यदि आप एक "फसल" चाहते हैं जो एक छवि के हिस्से को एक आयत के भीतर लौटाता है, तो आप एक आयत के साथ एक नई सतह पर ब्लिट कर सकते हैं या एक उपसतह की प्रतिलिपि बना सकते हैं।

pygame.transform.laplacian(Surface, DestSurface = None) -> Surface

एक सतह में किनारों को खोजें

लैपलैसियन एल्गोरिथ्म का उपयोग करके किनारों को सतह में ढूंढता है।

Pygame 1.8 में नया

pygame.transform.average_surfaces(Surfaces, DestSurface = None, palette_colors = 1) -> Surface

कई सतहों से औसत सतह पाते हैं।

सतहों का एक क्रम लेता है और प्रत्येक सतह से औसत रंगों के साथ एक सतह देता है।

palette_colors - अगर सच है तो हम पैलेट में रंगों को औसत करते हैं, अन्यथा हम पिक्सेल मूल्यों को औसत करते हैं। यह उपयोगी है अगर सतह वास्तव में ग्रेस्केल रंग है, न कि पैलेट रंग।

ध्यान दें, यह फ़ंक्शन वर्तमान में सतहों का सही ढंग से उपयोग करके पैलेट को संभालता नहीं है।

Pygame में नया 1.8 palette_colors pygame में नया तर्क 1.9

pygame.transform.average_color(Surface, Rect = None) -> Color

एक सतह का औसत रंग पाता है

सरफेस का औसत रंग या किसी Rect द्वारा निर्दिष्ट सतह के क्षेत्र को ढूँढता है, और इसे Color के रूप में लौटाता है।

pygame.transform.threshold(dest_surf, surf, search_color, threshold=(0,0,0,0), set_color=(0,0,0,0), set_behavior=1, search_surf=None, inverse_set=False) -> num_threshold_pixels

जो पाता है, और एक सतह में कितने पिक्सेल 'search_color' या 'search_surf' की सीमा के भीतर हैं।

इस बहुमुखी फ़ंक्शन का उपयोग रंगों को खोजने के लिए किया जा सकता है, जो 'search_color' के करीब या अलग 'search_surf' में रंगों के करीब होता है।

इसका उपयोग पिक्सेल को एक 'डेस्ट_सर्फ़' में स्थानांतरित करने के लिए किया जा सकता है जो मेल खाते हैं या मेल नहीं खाते हैं।

डिफ़ॉल्ट रूप से यह पिक्सल को 'dest_surf' में सेट करता है, जहाँ सभी पिक्सेल थ्रेशोल्ड के भीतर सेट_ कलर में नहीं बदले जाते हैं। यदि व्युत्क्रम_सेट वैकल्पिक रूप से True पर सेट है, तो थ्रेशोल्ड के भीतर जो पिक्सल हैं उन्हें set_color में बदल दिया जाता है।

यदि वैकल्पिक 'search_surf' सतह दी गई है, तो इसका उपयोग निर्दिष्ट 'set_color' के बजाय थ्रेशोल्ड करने के लिए किया जाता है। अर्थात्, यह प्रत्येक पिक्सेल को 'सर्फ' में मिलेगा जो कि 'search_surf' के समान निर्देशांक पर पिक्सेल की 'सीमा' के भीतर है।

पैरामीटर:
  • dest_surf ( pygame.Surface या कोई नहीं ) - सरफेस हम बदल रहे हैं। 'Set_behavior' देखें। यदि कोई भी गिनती (सेट_बेहवियर 0 है) होना चाहिए।
  • सर्फ ( pygame.Surface ) - सतह हम देख रहे हैं।
  • search_color ( pygame.Color ) - रंग जिसे हम खोज रहे हैं।
  • थ्रेसहोल्ड ( pygame.Color ) - search_color (या search_surf) से इस दूरी के भीतर। आप (आर, जी, बी, ए) का उपयोग कर सकते हैं, जहां आर, जी, बी अलग थ्रेसहोल्ड हो सकते हैं। यदि आप चाहें तो आप 40 की एक आर दहलीज और 2 की नीली दहलीज का उपयोग कर सकते हैं।
  • set_color ( pygame.Color या कोई नहीं ) - रंग हम dest_surf में सेट करते हैं।
  • set_behavior ( int ) -
    • set_behavior = 1 (डिफ़ॉल्ट)। Dest_surface में पिक्सेल को 'set_color' में बदल दिया जाएगा।
    • set_behavior = 0 हम 'dest_surf' नहीं बदलते, बस गिनती करते हैं। नियति_सुर्फ़ बनाना = कोई नहीं।
    • set_behavior = 'dest_surf' में 2 पिक्सेल सेट 'सर्फ' से होंगे।
  • search_surf ( pygame.Surface या कोई नहीं ) -
    • search_surf = कोई नहीं (डिफ़ॉल्ट)। इसके बजाय 'search_color' के खिलाफ खोजें।
    • search_surf = सतह। 'Search_color' का उपयोग करने के बजाय 'search_surf' में रंग देखें।
  • व्युत्क्रम_सेट ( बूल ) -
    • झूठा, डिफ़ॉल्ट। थ्रेशोल्ड के बाहर के पिक्सेल बदले जाते हैं।
    • सच है, थ्रेसहोल्ड के भीतर पिक्सेल बदले हुए हैं।
वापसी प्रकार:

पूर्णांक

यह दिखाता है:

या तो 'search_color' या search_surf की तुलना में 'सर्फ़' में 'सीमा' के भीतर पिक्सेल की संख्या।

उदाहरण:

उदाहरणों की एक पूरी के लिए सीमा परीक्षण देखें: https://github.com/pygame/pygame/blob/master/test/transform_test.py

    def test_threshold_dest_surf_not_change(self):
        """ the pixels within the threshold.

        All pixels not within threshold are changed to set_color.
        So there should be none changed in this test.
        """
        (w, h) = size = (32, 32)
        threshold = (20, 20, 20, 20)
        original_color = (25, 25, 25, 25)
        original_dest_color = (65, 65, 65, 55)
        threshold_color = (10, 10, 10, 10)
        set_color = (255, 10, 10, 10)

        surf = pygame.Surface(size, pygame.SRCALPHA, 32)
        dest_surf = pygame.Surface(size, pygame.SRCALPHA, 32)
        search_surf = pygame.Surface(size, pygame.SRCALPHA, 32)

        surf.fill(original_color)
        search_surf.fill(threshold_color)
        dest_surf.fill(original_dest_color)

        # set_behavior=1, set dest_surface from set_color.
        # all within threshold of third_surface, so no color is set.

        THRESHOLD_BEHAVIOR_FROM_SEARCH_COLOR = 1
        pixels_within_threshold = pygame.transform.threshold(
            dest_surf=dest_surf,
            surf=surf,
            search_color=None,
            threshold=threshold,
            set_color=set_color,
            set_behavior=THRESHOLD_BEHAVIOR_FROM_SEARCH_COLOR,
            search_surf=search_surf,
        )

        # # Return, of pixels within threshold is correct
        self.assertEqual(w*h, pixels_within_threshold)

        # # Size of dest surface is correct
        dest_rect = dest_surf.get_rect()
        dest_size = dest_rect.size
        self.assertEqual(size, dest_size)

        # The color is not the change_color specified for every pixel As all
        # pixels are within threshold

        for pt in test_utils.rect_area_pts(dest_rect):
            self.assertNotEqual(dest_surf.get_at(pt), set_color)
            self.assertEqual(dest_surf.get_at(pt), original_dest_color)

Pygame 1.8 1.9.4 में नए ने बहुत सारे बग्स तय किए और कीवर्ड तर्क जोड़े। अपने कोड का परीक्षण करें।