[Closed] Bitmap Processing Efficiencies

Hmm, I’m unable to replicate your <=1024px pre-declare performance. The pre-declare function is pretty consistently about 1.5-2x slower than the other two in my tests, regardless of resolution (I tested everything from 128sq to 4096sq pixels).

For me v2 is faster than v1 for 2048×2048, with v3 being the slowest.

Other than rewriting this in C++ (seriously, this would take like 3ms to execute), or making it multithreaded in maxscript, I think you’ve done all you can.

Even C# could do the trick if you’re ok with the color values of your bitmap being rounded to integers and clamped between 0-255.

This runs in 0.7 seconds on a 4k image…although I’m guessing you’re relying on 32bit EXRs for a reason and need the floating point values. Shame that SetClipboardBitmap clamps everything.

   global pb_classIter	
   
   if (pb_classIter == undefined) then pb_classIter = 100	
   pb_class = "processBitmap_" + pb_classIter as string
   pb_classIter += 1
   
   if classof (dotnet.GetType pb_class) != dotNetObject then
   (
   	classStr = "		
   	
   	using System;
   	using System.Drawing;
   	using System.Drawing.Imaging;
   	
   	class " + pb_class + "
   	{
   		public unsafe static float[] processbitmap (Bitmap map)
   		{
   			float min = 1000000;
   			float max = -100000;
   	
   	
   			BitmapData bData = map.LockBits(new Rectangle(0, 0, map.Width, map.Height), ImageLockMode.ReadWrite, map.PixelFormat);
   
   			byte bitsPerPixel = (byte)Image.GetPixelFormatSize(bData.PixelFormat);
   
   			byte* scan0 = (byte*)bData.Scan0.ToPointer();
   
   			for (int i = 0; i < bData.Height; ++i)
   			{
   				for (int j = 0; j < bData.Width; ++j)
   				{
   					byte* data = scan0 + i * bData.Stride + j * bitsPerPixel / 8;
   					float val = (0.3f*data[0] + 0.59f*data[1] + 0.11f*data[2]);	
   					min = Math.Min(min, val);
   					max = Math.Max(max, val);
   				}
   			}
   
   			map.UnlockBits(bData);
   	
   	
   			return new float[]{min/255.0f, max/255.0f};
   		}
   	
   	}
   	"
   	compilerParams = dotnetobject "System.CodeDom.Compiler.CompilerParameters"
   	dotnet.setlifetimecontrol compilerParams #dotnet
   		
   	compilerParams.CompilerOptions = "/unsafe"
   	compilerParams.ReferencedAssemblies.Add("System.dll");
   	compilerParams.ReferencedAssemblies.Add("System.Drawing.dll");			
   	compilerParams.ReferencedAssemblies.Add((getdir #maxroot) + @"Autodesk.Max.dll");
   	compilerParams.ReferencedAssemblies.Add((getdir #maxroot)+ @"ManagedServices.dll");
   	compilerParams.ReferencedAssemblies.Add((getdir #maxroot)+ @"MaxCustomControls.dll");
   	compilerParams.GenerateInMemory = on
   	csharpProvider = dotnetobject "Microsoft.CSharp.CSharpCodeProvider"
   		
   	compilerResults = csharpProvider.CompileAssemblyFromSource compilerParams #(classStr)
   	dotnet.setlifetimecontrol compilerResults #dotnet
   
   	if (compilerResults.Errors.Count > 0 ) then
   	(
   		
   		local errs = stringstream ""
   		for i = 0 to (compilerResults.Errors.Count-1) do
   		(
   			local err = compilerResults.Errors.Item[i]
   			format "Error:% Line:% Column:% %
" err.ErrorNumber err.Line err.Column err.ErrorText to:errs
   		)
   		format "%
" errs
   		undefined
   
   	)
   )
   
   fn getBitmapMaxMinValues_v4 map res:1.0 =
   (	
   	if res != 1.0 then
   	(
   	nBmp = bitmap (map.width*res) (map.height*res) hdr:true	
   	copy map nBmp
   	map = nBmp	
   	format "Map Rescaled to % x % pixels
" map.width map.height
   	)	
   	
   	
   	
   	st = timestamp()--get start time in milliseconds
   	
   	setClipboardBitmap map -- Copy the bitmap to the clipboard to pass it to dotNet	
   	clipboardObj = dotNetClass "System.Windows.Forms.Clipboard"  -- Create a dotNet clipboard object.	
   	imgObj = clipboardObj.GetImage() -- Get the image from the clipboard into a dotNet image object.
   	
   	minmax = ((dotnetclass pb_class).processbitmap imgObj)
   	
   		
   	format "Per Pixel Line Min/Max Processing took % seconds : % %x%
" ((timestamp()-st) / 1000.0) map.filename map.width map.height
   	minmax
   )
   

 getBitmapMaxMinValues_v4 b res:4
 
 Map Rescaled to 4096 x 4096 pixels
 Per Pixel Line Min/Max Processing took 0.668 seconds :  4096x4096
 #(0.0, 0.87902)
 

 

“Shame that SetClipboardBitmap clamps everything.”
I’ve never worked with bitmaps. Isn’t there any max object to hold the bitmap and then pass it to C# by handleByAnim instead of copying it to the clipboard.?

You’re not allocating any memory for the pixels, you’re only creating one. I’m not familiar with the c# SDK, but ideally you’d create an array the size of a row and pass a pointer to that.

Thanks everyone for your input. Even in the current state, it’s quicker than the round trip to nuke (and using a nuke license for that matter) to do a curvetool luma analysis. And yes Tyson, full float is really important as it’s being used as a displacement map. Even loading it via the max bitmap loader introduces noise that affects the render (the VrayHDRI loader doesn’t have this problem) so it’s important to be as accurate as possible.

Thanks also for your SDK suggestions, I regret to say that I know many programming languages, but C++ is just gobbledegook to me.

Another suggestion: read every 2nd, 3rd or 4th row. I would bet the error compared to reading every row will be negligible in almost all cases.

Any idea how to do that? I’m not super familiar with pointers in C#. I tried something like:

__Global.IGlobalBMM_Color_fl ctr = new __Global.__GlobalBMM_Color_fl();	
IBMM_Color_fl[] pix = new IBMM_Color_fl[bmp.Width];
GCHandle handle1 = GCHandle.Alloc(pix);		
IBMM_Color_fl ptr = ctr.Marshal((IntPtr)handle1);
bmp.GetPixels(0,0,bmp.Width,ptr)
handle1.Free();

…but it doesn’t work.

This is all guesswork on my part since these C# max functions aren’t documented…but the GetPixels function only takes a IBMM_Color_fl object as its input, and the Marshal function of the wrapper class seems to convert a pointer to an IBMM_Color_fl object…so I’m assuming the steps to get a row of pixels is create an array of IBMM_Color_fl, then get a pointer to that array and use Marshal on the pointer to get a IBMM_Color_fl object and pass that to the GetPixels function…?

I know you said you’re not familiar with the C# SDK, but maybe you could offer advice about how to allocate an array and get a pointer to it.

No such luck, they have really made this anything but easy.