def main(): path = storage.LoadDialog(type=c4d.FILESELECTTYPE_IMAGES, title="Please Choose a 32 Bit Image:") #path = "C:\\Users\\tobi\\Desktop\\test.jpg" if not path: return # Create and initialize selected image orig = bitmaps.BaseBitmap() if orig.InitWith(path)[0] != c4d.IMAGERESULT_OK: gui.MessageDialog("Cannot load image \"" + path + "\".") return width, height = orig.GetSize() bits = orig.GetBt() pxColl = [] for x in range (0,width): for y in range (0,height): pxColl.append( orig.GetPixel(x,y) ) samples = 16 seed = 500 pxColl.sort() i = 0 for x in range (0,width): for y in range (0,height): orig.SetPixel(x,y,int(pxColl[i][0]),int(pxColl[i][1]),int(pxColl[i][2])) i += 1 bitmaps.ShowBitmap(orig) copy = bitmaps.BaseBitmap() copy.Init(samples, 1, bits) collPic = [] for x in range(0,samples): #random.seed(x+seed) rgb =len(pxColl)/samples*x newcoll = pxColl[rgb][0],pxColl[rgb][1],pxColl[rgb][2] #print newcoll collPic.append( newcoll ) collPic.sort(key=lambda rgb: colorsys.rgb_to_hsv(*rgb)) i = 0 #print collPic for item in collPic: copy.SetPixel(i,0,item[0],item[1],item[2]) i += 1
def main(): size = 64 n = size*size s = (float(1)/float(n)) px = [] bmp = bitmaps.BaseBitmap() bmp.Init(size, size, depth=32) for i in xrange(0,n): px.append(i*s) x = 0 y = -1 i = 0 shuffle(px) for p in px: if (x % size == 0): y+=1 x =0 bmp.SetPixel(x, y, p*255,p*255 ,p*255 ) x +=1 bitmaps.ShowBitmap(bmp)
def main(): path = storage.LoadDialog(type=c4d.FILESELECTTYPE_IMAGES, title="Please Choose a 32-bit Image:") if not path: return # Create and initialize selected image orig = bitmaps.BaseBitmap() if orig.InitWith(path)[0] != c4d.IMAGERESULT_OK: gui.MessageDialog("Cannot load image \"" + path + "\".") return # Check if channel depth is really 32 bit if orig.GetBt()/3 != 32: gui.MessageDialog("The image \"" + path + "\" is not a 32 bit per-channel image.") return # Get selected image infos width, height = orig.GetSize() bits = orig.GetBt() # Create the copy and initialize it copy = bitmaps.BaseBitmap() copy.Init(width, height, bits) # Calculate the number of bytes per pixel inc = orig.GetBt()/8 # Each pixel has RGB bits, so we need an offset of 'inc' bytes per pixel # the image has 32 bits per-channel : (32*3)/8 = 12 bytes per pixel (1 byte = 8 bits) # the image has 3 channels per pixel (RGB) : 12/3 = 4 bytes per component = 1 float # Create a byte sequence buffer large enough to store the copied image pixels sq = storage.ByteSeq(None, width*height*inc) for row in xrange(height): offset = sq.GetOffset(row*(width*inc)) # Offset on bitmap row + offset bytes per pixel orig.GetPixelCnt(0, row, width, offset, inc, c4d.COLORMODE_RGBf, c4d.PIXELCNT_0) # Read pixels from the original bitmap into the buffer #Example: RGB value of first pixel (only for 32 bits) #import struct #r, g, b = struct.unpack("fff", sq[0:12]) #print r, g, b for row in xrange(height): offset = sq.GetOffset(row*(width*inc)) # Offset on bitmap row + offset bytes per pixel copy.SetPixelCnt(0, row, width, offset, inc, c4d.COLORMODE_RGBf, c4d.PIXELCNT_0) # Set pixels in bitmap copy bitmaps.ShowBitmap(orig) # Show original bitmaps.ShowBitmap(copy) # Show copied image
def __init__(self, doc): self.dest_file = '' self.doc = doc.GetClone(c4d.COPYFLAGS_DOCUMENT) self.render_data = self.doc.GetActiveRenderData().GetData() self.bmp = bitmaps.BaseBitmap() self.bmp.Init(x=int(self.render_data[c4d.RDATA_XRES]), y=int(self.render_data[c4d.RDATA_YRES]), depth=24) self.status = False
def __init__(self, aDoc, typeOfRender, aFlags, continious=False): self.continious = continious self._doc = aDoc self.typeOfRender = typeOfRender self._flags = aFlags self.rd = self._doc.GetActiveRenderData() self.bmp = bitmaps.BaseBitmap() self.bmp.Init(int(round(self.rd[c4d.RDATA_XRES_VIRTUAL])), int(round(self.rd[c4d.RDATA_YRES_VIRTUAL])), depth=24)
def main(): rd = doc.GetActiveRenderData().GetData() xres = int(round(rd[c4d.RDATA_XRES])) yres = int(round(rd[c4d.RDATA_YRES])) bmp = bitmaps.BaseBitmap() bmp.Init(xres, yres, depth=32) res = documents.RenderDocument(doc, rd, bmp, c4d.RENDERFLAGS_EXTERNAL) if res == c4d.RENDERRESULT_OK: bitmaps.ShowBitmap(bmp) if __name__ == '__main__': main()
def getImageSize(mat): pathToFile = '' try: pathToFile = mat[c4d.MATERIAL_COLOR_SHADER][c4d.BITMAPSHADER_FILENAME] except: try: pathToFile = mat[c4d.MATERIAL_LUMINANCE_SHADER][ c4d.BITMAPSHADER_FILENAME] except: return [400, 400] bmp = bitmaps.BaseBitmap(pathToFile) bmp.InitWith(pathToFile) w, h = bmp.GetSize() return [w, h]
def main(): path = storage.LoadDialog(type=c4d.FILESELECTTYPE_IMAGES, title="Please Choose an Image:") if not path: return # Create and initialize selected image img = bitmaps.BaseBitmap() if img.InitWith(path)[0] != c4d.IMAGERESULT_OK: gui.MessageDialog("Cannot load image \"" + path + "\".") return byteseq, size = WriteBitmap( img) # Save image to hyper file in byte sequence bmp = ReadBitmap(byteseq) # Read image from the byte sequence bitmaps.ShowBitmap(bmp)
def main(): size = 256 bmp = bitmaps.BaseBitmap() bmp.Init(size, size, depth=32) bmp.SetData(c4d.BASEBITMAP_DATA_GAMMA, 2.2) for x in xrange(0, (size)): for y in xrange(0, (size)): bmp.SetPixel(x, y, x * (float(1) / float(size)) * 255, y * (float(1) / float(size)) * 255 * -1 + 255, 0) bitmaps.ShowBitmap(bmp)
def importPalette(path): orig = bitmaps.BaseBitmap() if orig.InitWith(path)[0] != c4d.IMAGERESULT_OK: gui.MessageDialog("Cannot load image \"" + path + "\".") return width, height = orig.GetSize() if height != 1: gui.MessageDialog("This is not a MagicaVoxel .PNG Palette") else: for x in range(0, width): mat = doc.SearchMaterial(str(x + 1)) if mat: color = orig.GetPixel(x, 0) mat[c4d.MATERIAL_COLOR_COLOR] = c4d.Vector( float(color[0]) / 255, float(color[1]) / 255, float(color[2]) / 255)
def ReadBitmap(byteseq): """ Creates a bitmap from a buffer object. @return: The image if succeeded, otherwise False @byteseq: The buffer object. """ bmp = bitmaps.BaseBitmap() hf = storage.HyperFile() mfs = storage.MemoryFileStruct() bmp = None mfs.SetMemoryReadMode(byteseq, len(byteseq)) if hf.Open(0, mfs, c4d.FILEOPEN_READ, c4d.FILEDIALOG_NONE): bmp = hf.ReadImage() hf.Close() return bmp
def main(): docpath = doc.GetDocumentPath() picture = c4d.storage.LoadDialog(type=c4d.FILESELECTTYPE_IMAGES, flags=c4d.FILESELECT_LOAD, def_path=docpath) #create a standard material mat = c4d.BaseMaterial(c4d.Mmaterial) doc.StartUndo() #insert the material in the document doc.InsertMaterial(mat) doc.AddUndo(c4d.UNDOTYPE_NEW, mat) imgname = os.path.splitext(os.path.basename(picture))[0] mat[c4d.MATERIAL_USE_REFLECTION] = 0 mat.SetName(imgname) #create a bitmap shader xch = c4d.BaseList2D(c4d.Xbitmap) #set the path of the image file to the bitmap shader xch[c4d.BITMAPSHADER_FILENAME] = picture #set the shader to the color channel mat[c4d.MATERIAL_COLOR_SHADER] = xch #set the shader to the luminanz channel #mat[c4d.MATERIAL_LUMINANCE_SHADER] = xch #mat[c4d.MATERIAL_USE_LUMINANCE]=True #mat[c4d.MATERIAL_USE_COLOR]=False mat.InsertShader(xch) filename = xch[c4d.BITMAPSHADER_FILENAME] bm = bitmaps.BaseBitmap() bm.InitWith(filename) getsize = bm.GetSize() xpix = float(getsize[0]) ypix = float(getsize[1]) #internal update of the material mat.Message(c4d.MSG_UPDATE) #recalculate the thumbnails of the material mat.Update(True, True) # Normalize width to 200px ypixnorm = float(xpix/ypix) # Create plane plane = c4d.BaseObject(c4d.Oplane) plane[c4d.PRIM_PLANE_WIDTH] = 200 plane[c4d.PRIM_PLANE_HEIGHT] = 200/ypixnorm plane[c4d.PRIM_AXIS] = 5 plane[c4d.ID_BASELIST_NAME] = imgname plane[c4d.PRIM_PLANE_SUBW] = 1 plane[c4d.PRIM_PLANE_SUBH] = 1 doc.InsertObject(plane) doc.AddUndo(c4d.UNDOTYPE_NEW, plane) doc.EndUndo() # Create texture tag tag = plane.MakeTag(c4d.Ttexture) tag[c4d.TEXTURETAG_MATERIAL] = mat tag[c4d.TEXTURETAG_PROJECTION] = 6 # Create display tag disptag = plane.MakeTag(c4d.Tdisplay) disptag[c4d.DISPLAYTAG_AFFECT_DISPLAYMODE]=True # Set texture resolution maxres = int(max(ypix, xpix)) print maxres if maxres > 1024 and maxres < 2048: mat[c4d.MATERIAL_PREVIEWSIZE] = 11 elif maxres > 2048 and maxres < 4096: mat[c4d.MATERIAL_PREVIEWSIZE] = 12 elif maxres > 4096 and maxres < 8192: mat[c4d.MATERIAL_PREVIEWSIZE] = 13 elif maxres > 8192: mat[c4d.MATERIAL_PREVIEWSIZE] = 14 else: mat[c4d.MATERIAL_PREVIEWSIZE] = 10 c4d.EventAdd()
if self.dialog is None: self.dialog = MakeAwesomeButtonDialog() return self.dialog.Open(c4d.DLG_TYPE_ASYNC, pluginid=ID_MAKEAWESOMEBUTTON) def RestoreLayout(self, secref): # manage nonmodal dialog if self.dialog is None: self.dialog = MakeAwesomeButtonDialog() return self.dialog.Restore(pluginid=ID_MAKEAWESOMEBUTTON, secret=secref) if __name__ == "__main__": thispath = os.path.dirname(os.path.abspath(__file__)) icon = bitmaps.BaseBitmap() icon.InitWith(os.path.join(thispath, "res", "icon.png")) plugins.RegisterCommandPlugin(ID_MAKEAWESOMEBUTTON, PLUGIN_NAME, 0, icon, PLUGIN_HELP, MakeAwesomeButtonMain()) print(u"%s v%s loaded. (C) %s ${FULLNAME}" % (PLUGIN_NAME, PLUGIN_VERSION, CR_YEAR)) # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import c4d from c4d import gui from c4d import bitmaps, documents from random import shuffle size = 64 n = size * size s = (float(1) / float(n)) px = [] bmp = bitmaps.BaseBitmap() bmp.Init(size, size, depth=32) for i in xrange(0, n): px.append(i * s) x = 0 y = -1 i = 0 shuffle(px) r = list(px) shuffle(px) g = list(px) shuffle(px) b = list(px) for i in range(len(px)): if (x % size == 0): y += 1
def main(): # globale Variablen übernehmen global scaleart, orig, alpha, button, showo, shows, bitmapfile c4d.CallCommand(13957) # Pythonkonsole leeren # Objekt ausgewählt? Sonst Fehlerausgabe und beenden if not op: gui.MessageDialog("Please select a object!") return False # EXIT # Prüfen ob das Objekt ein Polygonobjekt ist if (op.GetType() == 5100): # 5100 ist der Type für das Polygonobjekt print else: gui.MessageDialog("ERROR - Object is not a polygon object?") return False # Erstes UVTag auslesen uvtag = op.GetTag(c4d.Tuvw) # Kein UVW Tag? Sonst Fehlerausgabe und beenden if not uvtag: gui.MessageDialog("Please assign UVW to the object") return # Dialog aufrufen dlg = Dialog() dlg.Open(c4d.DLG_TYPE_MODAL) if (button == 0): return False # Kein Button gedrückt (z.B. beim Fenster schließen über Fensterelement X) # Bitmap Variablen vorbereiten smallbitm = bitmaps.BaseBitmap() bitmap = bitmaps.BaseBitmap() bitmapPath = bitmapfile if (button == 1024): abspath = bitmapfile bitmapPath = bitmapfile else: # Selektiertes Tag auslesen ttag = doc.GetActiveTag() if ( not ttag or not ttag.CheckType(c4d.Ttexture) ): # Falls kein Material Tag vorhanden oder/und ausgewählt - abbrechen gui.MessageDialog( "Please attach AND SELECT a Material to the object!") return False # Material der Variable mat zuweisen mat = ttag.GetMaterial() # Kein Material übernehmen können? Dann Fehlerausgabe und beenden if not mat: gui.MessageDialog( "Please attach a Material with simple bitmap in color Channel to the object!" ) return False # EXIT # Farbkanal auslesen falls Variable alpha = 0 (Button links gedrückt) if (alpha == 0): if (mat[c4d.MATERIAL_USE_COLOR] == True ): # ist der Color kanal des Materials aktiv? shader = mat[c4d.MATERIAL_COLOR_SHADER] # dann Shader auslesen else: gui.MessageDialog("Miss COLOR Channel!") return False # Exit # Alphakanal auslesen falls Variable alpha = 1 (Button mitte gedrückt) if (alpha == 1): if (mat[c4d.MATERIAL_USE_ALPHA] == True ): # ist der Alpha kanal des Materials aktiv? shader = mat[c4d.MATERIAL_ALPHA_SHADER] # dann Shader auslesen else: gui.MessageDialog("Miss ALPHA Channel!") return False # Exit # Farbkanal / Alphakanal konnte nicht gelesen werden? if shader is None: if (alpha == 0): gui.MessageDialog( "Can't get the Shader!\nPlease check that the COLOR Channel is not empty!" ) if (alpha == 1): gui.MessageDialog( "Can't get the Shader!\nPlease check that the ALPHA Channel is not empty!" ) return False # EXIT # Shader vor dem auslesen erst abrufbar machen!!! bitmapPath = shader[c4d.BITMAPSHADER_FILENAME] # Shadertyp und Filename bei Bitmapshader auslesen name, path = shader.GetName(), shader[c4d.BITMAPSHADER_FILENAME] #if bitmapPath is´nt absolute if not os.path.dirname(bitmapPath): #the document has´nt been saved already ->picture in user library if not doc.GetDocumentPath(): abspath = c4d.storage.GeGetStartupWritePath( ) + "/" + "tex" + "/" + bitmapPath #the picture should be inside the asset´s texture folder else: abspath = doc.GetDocumentPath() + "/" + bitmapPath else: abspath = bitmapPath # if op is not None: # Bitmap mit vollem Pfad und Dateinamen Initialisieren: result = bitmap.InitWith(abspath) if (button <> 1024): irs = render.InitRenderStruct() else: irs = True if (button <> 1024): shader.InitRender(irs) if irs: # Bitmapdateien in Shadern können absolut oder relativ gespeichert werden. # Also muss geprüft werden ob der komplette Pfad ausgelesen wurde! # Falls Bitmap ordnungsgemäß verarbeitet wurde: if result: # Die Variable bitmap wurde jetzt auf eine von 3 Arten befüllt: if bitmap is not None: # hats geklappt? Dann weiter: width, height = bitmap.GetSize( ) # Pixel-Maße der Bilddatei auslesen bits = bitmap.GetBt() # Bittiefe auslesen pixelzahl = width * height # Gesamtpixelanzahl ermitteln punktezahl = uvtag.GetDataCount( ) # Punkteanzahl der UVW-Map ermitteln # Scalierung auf basis des Skalierungs-Sliders berechnen # Aufgrund der Differenz der Auflösung der Bilddatei # und der Auflösung des Polygonmesh (bzw. der UVW-Map) # berechnet sich die Scalierung der Bilddatei. # Die Bilddatei wird skaliert damit in einer hohen Bildauflösung # ein einzelner ausgerissener Pixel den Punkt in einem niedrig aufgelösen Mesh # nicht so stark beeinflusst beeinflusst. nur weil der UV-Punkt genau auf diesem Pixel liegt. differenz = pixelzahl - punktezahl # Differenz ermitteln if scaleart == 10: diffadd = float( differenz ) / 1000 # Neue Bildgröße = Anzahl der Punkte der UV-Map + Differenz geteilt durch 1000 if scaleart == 9: diffadd = float( differenz ) / 500 # Neue Bildgröße = Anzahl der Punkte der UV-Map + Differenz geteilt durch 500 if scaleart == 8: diffadd = float( differenz ) / 100 # Neue Bildgröße = Anzahl der Punkte der UV-Map + Differenz geteilt durch 100 if scaleart == 7: diffadd = float( differenz ) / 50 # Neue Bildgröße = Anzahl der Punkte der UV-Map + Differenz geteilt durch 50 if scaleart == 6: diffadd = float( differenz ) / 20 # Neue Bildgröße = Anzahl der Punkte der UV-Map + Differenz geteilt durch 20 if scaleart == 5: diffadd = float( differenz ) / 10 # Neue Bildgröße = Anzahl der Punkte der UV-Map + Differenz geteilt durh 10 if scaleart == 4: diffadd = float( differenz ) / 5 # Neue Bildgröße = Anzahl der Punkte der UV-Map + Differenz geteilt durch 5 if scaleart == 3: diffadd = float( differenz ) / 3 # Neue Bildgröße = Anzahl der Punkte der UV-Map + ein Drittel der Differenz if scaleart == 1: diffadd = float( differenz ) / 2 # Neue Bildgröße = Anzahl der Punkte der UV-Map + die Hälfte der Differenz if scaleart == 2: diffadd = float( (differenz / 3) ) * 2 # Neue Bildgröße = Anzahl der Punkte der UV-Map + Zwei Drittel der Differenz if scaleart == 0: diffadd = differenz # Neue Bildgröße = Anzahl der Punkte der UV-Map + komplette Defferenz - Also volle Auflösung! # Geladenes Bild bestimmt das Seitenverhältnis. Anhand der alten Menge an Pixel, # der zur Verfügung stehenden Punkte im UV-Mesh und dem Grad der Skalierung (Slider) # wird die neue Bildgröße berechnet. mit gleich bleibenden Seitenverhältnis. # Scalierungsfaktor berechnen: Punkte+Pixelreduzierung geteilt durch Pixelanzahl scalefaktor = float(punktezahl + diffadd) / (pixelzahl) # Anhand des Skalierungsfaktors der Fläche die Seitenlängen berechnen scale_width = int(width * math.sqrt(scalefaktor)) scale_height = int(height * math.sqrt(scalefaktor)) # Kleinere Version der Bitmap erstellen smallbitm.Init( scale_width, scale_height, bits ) # Kleinere Maße, gleiche Bittiefe, gleiches Seitenverhältnis # Copy&Scale Original Bitmap zu Kleine Bitmap bitmap.ScaleBicubic(smallbitm, 0, 0, width - 1, height - 1, 0, 0, scale_width - 1, scale_height - 1) if (showo == True): bitmaps.ShowBitmap(bitmap) if (shows == True): bitmaps.ShowBitmap(smallbitm) bitmap = smallbitm else: gui.MessageDialog("Bitmap-Error") return False if (button <> 1024): shader.FreeRender() # Abbrechen falls Bitmap nicht übergeben werden konnte if bitmap is None: gui.MessageDialog("Bitmap can't load") return False else: # Im Kanal steckt keine einfache Bitmap-Datei. Wahrscheinlich ein prozeduraler Shader, oder Ebenen ect. gui.MessageDialog("In channel ist not a simple bitmap") return False # EXIT # Es wird eine Vertexmap erstellt die gleichviele Punkte enthält wie das Polygonobjekt vtag = c4d.VariableTag(c4d.Tvertexmap, op.GetPointCount()) bitmap_w = bitmap.GetBw() # Breite der Bitmap auslesen bitmap_h = bitmap.GetBh() # Höhe der Bitmap auslesen pixel = (bitmap_w * bitmap_h) # Pixelanzahl des Skalierten Bildes points = uvtag.GetDataCount() # Punktanzahl des UVW-Tags if (op.GetPointCount() > 0): # Prüfen ob das Objekte Punkte zum auslesen hat vertexList = op.GetPointCount() * [ 0 ] # Die Variable für die Vertagsmap-Befüllung mit der Anzahl an Punkten des selektierten Objektesvorbereiten else: gui.MessageDialog( "Object have no read able points! Is it a polygon object?") return False # Schleife liest jedes UVW-tag Polygon aus. Ein Punkt eines UVW-Tags kann mehreren Polygonobjekt-Punkten zugewisen sein # Es wird der Reihe nach jedes UV-Polygon ausgelesen. Dann wird das zugehörige Polygon des Objektes ausgelesen und # dessen Punkte mit den Farbwerten der Bitmap gefüllt. Die Anzahl der Polygonpunkte müssen nämlich gleich sein mit der Anzahl der Vertexmap-Punkte # Laut Wiki: Grauwert = 0,299 × Rotanteil + 0,587 × Grünanteil + 0,114 × Blauanteil for i in xrange(uvtag.GetDataCount() ): # Schleife durchläuft Polygone des UVW-Tag uvwdict = uvtag.GetSlow(i) # UVW-Polygon wird eingelesen objpolygon = op.GetPolygon(i) # Objekt-Polygon wird eingelesen point_a = op.GetPoint( objpolygon.a) # Objekt Polygon-PunktA ID wird ausgelesen point_b = op.GetPoint( objpolygon.b) # Objekt Polygon-PunktB ID wird ausgelesen point_c = op.GetPoint( objpolygon.c) # Objekt Polygon-PunktC ID wird ausgelesen point_d = op.GetPoint( objpolygon.d) # Objekt Polygon-PunktD ID wird ausgelesen u = uvwdict[ "a"].x # UVW-Koordinate des Punktes A wird ermittelt v = uvwdict[ "a"].y # UVW-Koordinate des Punktes A wird ermittelt w = uvwdict["a"].z ux = bitmap_w * u # UV-Koordinate liegt zwischen 0-1 und wird mit der Bildbreite multipliziert uy = bitmap_h * v # UV-Koordinate liegt zwischen 0-1 und wird mit der Bildhöhe multipliziert color = bitmap.GetPixel(int(ux), int(uy)) # "ubjektiver" Helligkeitswert aus RGB ermitteln weight_a = 0.299 * (float(color[0]) / 256) + 0.587 * ( float(color[1]) / 256) + 0.114 * (float(color[2]) / 256) u = uvwdict[ "b"].x # UVW-Koordinate des Punktes B wird ermittelt v = uvwdict[ "b"].y # UVW-Koordinate des Punktes B wird ermittelt w = uvwdict["b"].z ux = bitmap_w * u # UV-Koordinate liegt zwischen 0-1 und wird mit der Bildbreite multipliziert uy = bitmap_h * v # UV-Koordinate liegt zwischen 0-1 und wird mit der Bildhöhe multipliziert color = bitmap.GetPixel(int(ux), int(uy)) # "ubjektiver" Helligkeitswert aus RGB ermitteln weight_b = 0.299 * (float(color[0]) / 256) + 0.587 * ( float(color[1]) / 256) + 0.114 * (float(color[2]) / 256) u = uvwdict[ "c"].x # UVW-Koordinate des Punktes C wird ermittelt v = uvwdict[ "c"].y # UVW-Koordinate des Punktes C wird ermittelt w = uvwdict["c"].z ux = bitmap_w * u # UV-Koordinate liegt zwischen 0-1 und wird mit der Bildbreite multipliziert uy = bitmap_h * v # UV-Koordinate liegt zwischen 0-1 und wird mit der Bildhöhe multipliziert color = bitmap.GetPixel(int(ux), int(uy)) # "ubjektiver" Helligkeitswert aus RGB ermitteln weight_c = 0.299 * (float(color[0]) / 256) + 0.587 * ( float(color[1]) / 256) + 0.114 * (float(color[2]) / 256) u = uvwdict[ "d"].x # UVW-Koordinate des Punktes D wird ermittelt v = uvwdict[ "d"].y # UVW-Koordinate des Punktes D wird ermittelt w = uvwdict["d"].z ux = bitmap_w * u # UV-Koordinate liegt zwischen 0-1 und wird mit der Bildbreite multipliziert uy = bitmap_h * v # UV-Koordinate liegt zwischen 0-1 und wird mit der Bildhöhe multipliziert color = bitmap.GetPixel(int(ux), int(uy)) # "ubjektiver" Helligkeitswert aus RGB ermitteln weight_d = 0.299 * (float(color[0]) / 256) + 0.587 * ( float(color[1]) / 256) + 0.114 * (float(color[2]) / 256) # Helligkeitswerte der Vertexmap Wert-Variable zuweisen vertexList[objpolygon.a] = weight_a vertexList[objpolygon.b] = weight_b vertexList[objpolygon.c] = weight_c vertexList[objpolygon.d] = weight_d if vtag: # falls die Vertexmap auch wirlich erstellt wurde kann es weiter gehen: op.InsertTag(vtag) # Vertexmap wird an dem objekt erstellt vtag.SetAllHighlevelData( vertexList ) # erstellte Vertexmap wird mit den ermittelten Werten gefüllt c4d.EventAdd( ) # Veränderung in der Szene mitteilen, damit C4D aktualisiert. else: # Das Vorbereiten der Bitmapinitialisierung hat fehlgeschlagen: gui.MessageDialog("Can Not Init Shader") if irs == c4d.INITRENDERRESULT_OUTOFMEMORY: gui.MessageDialog("Out Of Memory") if irs == c4d.INITRENDERRESULT_ASSETMISSING: gui.MessageDialog("Texture Not Assigned") if irs == c4d.INITRENDERRESULT_UNKNOWNERROR: gui.MessageDialog("Unknown Error") if irs == c4d.INITRENDERRESULT_THREADEDLOCK: gui.MessageDialog("Threaded Lock") gui.MessageDialog(" - Finish - ")
import c4d import os from c4d import bitmaps, storage from c4d import utils, gui from c4d.gui import GeDialog from c4d.modules import render import math chlist = [] scaleart = 0 button = 0 alpha = 0 orig = bitmaps.BaseBitmap() objekttext = "" showo = False shows = False bitmapfile = "" # Dialog erstellen class Dialog(GeDialog): global objekttext, showo, shows def __init__(self): pass # Layout definieren def CreateLayout(self): # Objektname in Beschreibungstext einfügen objekttext = "Selected object is: " + op.GetName() self.SetTitle("RenameTexture") # Titel definieren