नुकीले और मेनकोडर के साथ सीधे फिल्म पर प्लॉटिंग

Question

तो, यह this thread पर टिप्पणी होना चाहिए, लेकिन यह स्पष्ट रूप से बंद है, इसलिए यह यहां जाता है। मैं matplotlib और numpy और mencoder के साथ काफी सफलतापूर्वक खेल रहा हूं, जैसा कि यहां बताया गया है। मैंने बाद में Voki Codder buffer to stdin solution अपनाया है, जो पूरी प्रक्रिया को काफी हद तक गति देता है। बात यह है कि, मुझे कमांड के -format = "bgra" भाग पर कोई दस्तावेज नहीं मिला। इसका मतलब है कि बाइट दाएं से बाएं नीले हरे लाल अल्फा से हैं, ठीक है। क्या उन्हें uint32, या कुछ और होना है। समस्या यह है कि मैं फ्लोट्स के रंगमंच की योजना बना रहा हूं, इसलिए मैं उन्हें ग्रेस्केल में बदलने की कोशिश कर रहा हूं, लेकिन मुझे बहुत सारे अजीब पैटर्न मिल रहे हैं जो मुझे दृढ़ विश्वास करते हैं कि मैं कुछ गलत कर रहा हूं। मैंने इस समारोह को एक सीमा के भीतर फ्लोट्स से uint32 में बदलने के लिए लिखा था। लेकिन नतीजा यह नहीं है कि मैं क्यों उम्मीद कर रहा था, क्या मैं कुछ बेवकूफ कर रहा हूँ?

def grayscale(x, min, max): 
    return np.uint32((x-min)/(max-min)*0xffffff) 

Answer 1

मैं तुम्हें क्या uint32 का प्रतिनिधित्व करता है पर भ्रमित हो रहे हैं लगता है। यह uint8 पूर्णांक के 4 बैंड हैं।

यदि आपके पास फ्लोटिंग पॉइंट डेटा है, और ग्रेस्केल में इसका प्रतिनिधित्व करना चाहते हैं, तो आप इसे पूर्ण 32 बिट रेंज में पुन: सहेजना नहीं चाहते हैं, आप इसे 8-बिट रेंज में पुन: सहेजना चाहते हैं, और इसे दोहराना चाहते हैं लाल, हरे और नीले रंग के बैंड (और फिर संभवतः एक स्थिर अल्फा बैंड में डाल दिया जाता है)।

आप एक अलग बाइटऑर्डर का भी उपयोग कर सकते हैं। Y8 सिर्फ एक सिंगल ग्रेस्केल, 8-बिट बैंड है, और Y16 एक एकल, ग्रेस्केल 16-बिट बैंड है। (एक पूर्ण (हालांकि कुछ भ्रामक) लिस्टिंग के लिए mencoder -rawvideo format=help के उत्पादन पर एक नज़र डालें।)

बस 8 बिट पूर्णांकों के चार बैंड के रूप में देखने के लिए numpy एक 32-बिट पूर्णांक का उपयोग कर वर्णन करने के लिए:

import numpy as np 
height, width = 20,20 

# Make an array with 4 bands of uint8 integers 
image = np.zeros((height, width, 4), dtype=np.uint8) 

# Filling a single band (red) 
b,g,r,a = image.T 
r.fill(255) 

# Fill the image with yellow and leave alpha alone 
image[...,:3] = (255, 255, 0) 

# Then when we want to view it as a single, 32-bit band: 
image32bit = image.reshape(-1).view(np.uint32).reshape(height, width) 
# (Note that this is a view. In other words, we could change "b" above 
# and it would change "image32bit") 

अपने मामले में, हालांकि, आप शायद कुछ इस तरह अधिक कार्य करना चाहते:

import numpy as np 
from videosink import VideoSink 

height, width = 20,20 
numframes = 1000 
data = np.random.random((height, width, numframes)) 

# Rescale your data into 0-255, 8-bit integers 
# (This could be done in-place if you need to conserve memory) 
d ata_rescaled = 255.0/(data.max() - data.min()) * (data - data.min()) 
data_rescaled = data_rescaled.astype(np.uint8) 

# The key here is the "Y8" format. It's 8-bit grayscale. 
video = VideoSink((height,width), "test", rate=20, byteorder="Y8") 

# Iterate over last axis 
for frame in data.T: 
    video.run(frame.T) 
video.close()