Diff of /cpyBuf.cpp [68cdf8] .. [ed05d7]  Maximize  Restore

Switch to side-by-side view

--- a/cpyBuf.cpp
+++ b/cpyBuf.cpp
@@ -1,7 +1,3 @@
-
-// PTLens, Copyright (C) 2004, Thomas Niemann
-// email: thomasn@epaperpress.com, subject=ptlens
-// 
 // This program is free software; you can redistribute 
 // it and/or modify it under the terms of the GNU
 // General Public License as published by the Free 
@@ -19,180 +15,225 @@
 // write to the Free Software Foundation, Inc., 675 
 // Mass Ave, Cambridge, MA 02139, USA.
 
+/**
+* @file CypBuf.cpp
+* This file is included in all four plug-ins (PTAdjust, PTCorrect, PTPerspect, and PTRemap)
+* It contains two functions for converting image buffers between photoshop and 
+* panotools internal formats.
+* @date January 2007
+*/
+
 #include "main.h"
 
-int cpyBufToPs(void *buf) {
-
-	// some local variables for efficiency
-	int16 tileHeight = gFr->filterRect.bottom - gFr->filterRect.top;
-	int16 tileWidth = gFr->filterRect.right - gFr->filterRect.left;
-	Rect *outRect = &gFr->outRect;
-	Rect *filterRect = &gFr->filterRect;
-	int16 imageWidth = PHO.imageWidth;
-	int16 imageHeight = PHO.imageHeight;
-	int32 imageDepth = PHO.imageDepth;
-	int32 bytesPerPixel = (imageDepth/8) * 3;
-
-	// round up to the nearest horizontal and vertical tile count
-	uint16 tilesVert = (uint16)((tileHeight - 1 + imageHeight) / tileHeight);
-	uint16 tilesHoriz = (uint16)((tileWidth - 1 + imageWidth) / tileWidth);
-
-	// Fixed numbers are 16.16 values 
-	// the first 16 bits represent the whole number
-	// the last 16 bits represent the fraction
-	gFr->inputRate = (int32)1 << 16;
-	gFr->maskRate = (int32)1 << 16;
+/**
+* Copy Image Buffer data from Panotool to Photoshop format
+* @param[in,out] buf the buffer to copy
+* @return 0 on success
+**/
+int cpyBufToPs(void *buf)
+{
+  // some local variables for efficiency
+  int16 tileHeight = gFr->filterRect.bottom - gFr->filterRect.top;
+  int16 tileWidth = gFr->filterRect.right - gFr->filterRect.left;
+  Rect *outRect = &gFr->outRect;
+  Rect *filterRect = &gFr->filterRect;
+  int16 imageWidth = PHO.imageWidth;
+  int16 imageHeight = PHO.imageHeight;
+  int32 imageDepth = PHO.imageDepth;
+  int32 bytesPerPixel = (imageDepth/8) * 3;
+
+  // round up to the nearest horizontal and vertical tile count
+  uint16 tilesVert = (uint16)((tileHeight - 1 + imageHeight) / tileHeight);
+  uint16 tilesHoriz = (uint16)((tileWidth - 1 + imageWidth) / tileWidth);
+
+  // Fixed numbers are 16.16 values 
+  // the first 16 bits represent the whole number
+  // the last 16 bits represent the fraction
+  gFr->inputRate = (int32)1 << 16;
+  gFr->maskRate = (int32)1 << 16;
  
-	// loop through each tile makeing sure we don't go over the bounds
-	// of the imageHeight or imageWidth
-	for (uint16 vertTile = 0; vertTile < tilesVert; vertTile++)	{
-		for (uint16 horizTile = 0; horizTile < tilesHoriz; horizTile++) {
-			outRect->top = (int16)(vertTile * tileHeight);
-			outRect->left = (int16)(horizTile * tileWidth);
-			outRect->bottom = (int16)(outRect->top + tileHeight);
-			outRect->right = (int16)(outRect->left + tileWidth);
-
-			if (outRect->bottom > imageHeight)
-				outRect->bottom = imageHeight;
-			if (outRect->right > imageWidth)
-				outRect->right = imageWidth;
-
-			for (uint16 plane = 0; plane < 3; plane++) {
-				// we want one plane at a time, small memory foot print is good
-				gFr->outLoPlane = plane;
-				gFr->outHiPlane = plane;
-	
-				// update the gFr with our latest request
-				*gResult = gFr->advanceState();
-				if (*gResult != noErr) 
-					return display("cpyBufToPs: advanceState");
-				
-				// copy one channel at a time
-				if (imageDepth == 8) {
-					uint8* pixel = (uint8*)gFr->outData;
-					uint16 rectHeight = (uint16)(outRect->bottom - outRect->top);
-					uint16 rectWidth = (uint16)(outRect->right - outRect->left);
-
-					for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++) {
-						Ptr dissolve = (char *)buf + bytesPerPixel * 
-							(imageWidth * (outRect->top + pixelY) + outRect->left) + plane;
-						for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++) {
-							*pixel++ = *dissolve;
-							dissolve += bytesPerPixel;
-						}
-						pixel += gFr->outRowBytes - rectWidth;
-					}
-				} else {
-					// assume 16-bit
-					uint16* pixel = (uint16*)gFr->outData;
-					uint16 rectHeight = (uint16)(outRect->bottom - outRect->top);
-					uint16 rectWidth = (uint16)(outRect->right - outRect->left);
-					int bytesPerPixel2 = bytesPerPixel >> 1;
-
-					for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++) {
-						uint16 *dissolve = (uint16 *)((char *)buf + bytesPerPixel * 
-							(imageWidth * (outRect->top + pixelY) + outRect->left)
-							+ 2*plane);
-						for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++) {
-							// convert 0..65535 to 0..32768
-							*pixel++ = (*dissolve + 1U) >> 1;
-							dissolve += bytesPerPixel2;
-						}
-						pixel += (gFr->outRowBytes - 2*rectWidth) >> 1;
-					}							
-				}
-			}
-
-		}
-	}
-
-	return 0;
+  // loop through each tile makeing sure we don't go over the bounds
+  // of the imageHeight or imageWidth
+  for (uint16 vertTile = 0; vertTile < tilesVert; vertTile++)
+  {
+    for (uint16 horizTile = 0; horizTile < tilesHoriz; horizTile++)
+    {
+      outRect->top = (int16)(vertTile * tileHeight);
+      outRect->left = (int16)(horizTile * tileWidth);
+      outRect->bottom = (int16)(outRect->top + tileHeight);
+      outRect->right = (int16)(outRect->left + tileWidth);
+
+      if (outRect->bottom > imageHeight)
+      {
+        outRect->bottom = imageHeight;
+      }
+      if (outRect->right > imageWidth)
+      {
+        outRect->right = imageWidth;
+      }
+
+      for (uint16 plane = 0; plane < 3; plane++)
+      {
+        // we want one plane at a time, small memory foot print is good
+        gFr->outLoPlane = plane;
+        gFr->outHiPlane = plane;
+  
+        // update the gFr with our latest request
+        *gResult = gFr->advanceState();
+        if (*gResult != noErr) 
+        {
+          return display("cpyBufToPs: advanceState");
+        }
+        
+        // copy one channel at a time
+        if (imageDepth == 8)
+        {
+          uint8* pixel = (uint8*)gFr->outData;
+          uint16 rectHeight = (uint16)(outRect->bottom - outRect->top);
+          uint16 rectWidth = (uint16)(outRect->right - outRect->left);
+
+          for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++)
+          {
+            Ptr dissolve = (char *)buf + bytesPerPixel * 
+              (imageWidth * (outRect->top + pixelY) + outRect->left) + plane;
+            for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++)
+            {
+              *pixel++ = *dissolve;
+              dissolve += bytesPerPixel;
+            }
+            pixel += gFr->outRowBytes - rectWidth;
+          }//pixelY
+        }//8 bit
+        else
+        {
+          // assume 16-bit
+          uint16* pixel = (uint16*)gFr->outData;
+          uint16 rectHeight = (uint16)(outRect->bottom - outRect->top);
+          uint16 rectWidth = (uint16)(outRect->right - outRect->left);
+          int bytesPerPixel2 = bytesPerPixel >> 1;
+
+          for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++)
+          {
+            uint16 *dissolve = (uint16 *)((char *)buf + bytesPerPixel * 
+              (imageWidth * (outRect->top + pixelY) + outRect->left)
+              + 2*plane);
+            for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++)
+            {
+              // convert 0..65535 to 0..32768
+              *pixel++ = (*dissolve + 1U) >> 1;
+              dissolve += bytesPerPixel2;
+            }
+            pixel += (gFr->outRowBytes - 2*rectWidth) >> 1;
+          }//pixelY
+        }//16 bit
+      }//plane
+    }//horizTile
+  }//vertTile
+
+  return 0;
 }
 
-int cpyPsToBuf(void *buf) {
-	// some local variables for efficiency
-	int16 tileHeight = gFr->filterRect.bottom - gFr->filterRect.top;
-	int16 tileWidth = gFr->filterRect.right - gFr->filterRect.left;
-	Rect *inRect = &gFr->inRect;
-	Rect *filterRect = &gFr->filterRect;
-	int16 imageWidth = PHO.imageWidth;
-	int16 imageHeight = PHO.imageHeight;
-	int32 imageDepth = PHO.imageDepth;
-	int32 bytesPerPixel = (imageDepth/8) * 3;
-
-	// round up to the nearest horizontal and vertical tile count
-	uint16 tilesVert = (uint16)((tileHeight - 1 + imageHeight) / tileHeight);
-	uint16 tilesHoriz = (uint16)((tileWidth - 1 + imageWidth) / tileWidth);
-
-	// Fixed numbers are 16.16 values 
-	// the first 16 bits represent the whole number
-	// the last 16 bits represent the fraction
-	gFr->inputRate = (int32)1 << 16;
-	gFr->maskRate = (int32)1 << 16;
+/**
+* Copy Image Buffer data from Photoshop to Panotool format
+* @param[in,out] buf the buffer to copy
+* @return none
+**/
+int cpyPsToBuf(void *buf)
+{
+  // some local variables for efficiency
+  int16 tileHeight = gFr->filterRect.bottom - gFr->filterRect.top;
+  int16 tileWidth = gFr->filterRect.right - gFr->filterRect.left;
+  Rect *inRect = &gFr->inRect;
+  Rect *filterRect = &gFr->filterRect;
+  int16 imageWidth = PHO.imageWidth;
+  int16 imageHeight = PHO.imageHeight;
+  int32 imageDepth = PHO.imageDepth;
+  int32 bytesPerPixel = (imageDepth/8) * 3;
+
+  // round up to the nearest horizontal and vertical tile count
+  uint16 tilesVert = (uint16)((tileHeight - 1 + imageHeight) / tileHeight);
+  uint16 tilesHoriz = (uint16)((tileWidth - 1 + imageWidth) / tileWidth);
+
+  // Fixed numbers are 16.16 values 
+  // the first 16 bits represent the whole number
+  // the last 16 bits represent the fraction
+  gFr->inputRate = (int32)1 << 16;
+  gFr->maskRate = (int32)1 << 16;
  
-	// loop through each tile makeing sure we don't go over the bounds
-	// of the imageHeight or imageWidth
-	for (uint16 vertTile = 0; vertTile < tilesVert; vertTile++)	{
-		for (uint16 horizTile = 0; horizTile < tilesHoriz; horizTile++)	{
-			inRect->top = (int16)(vertTile * tileHeight);
-			inRect->left = (int16)(horizTile * tileWidth);
-			inRect->bottom = (int16)(inRect->top + tileHeight);
-			inRect->right = (int16)(inRect->left + tileWidth);
-
-			if (inRect->bottom > imageHeight)
-				inRect->bottom = imageHeight;
-			if (inRect->right > imageWidth)
-				inRect->right = imageWidth;
-
-			for (uint16 plane = 0; plane < 3; plane++) {
-				// we want one plane at a time, small memory foot print is good
-				gFr->inLoPlane = plane;
-				gFr->inHiPlane = plane;
-	
-				// update the gFr with our latest request
-				*gResult = gFr->advanceState();
-				if (*gResult != noErr) 
-					return display("cpyPsToBuf: advanceState");
-
-				// copy one channel at a time
-				if (imageDepth == 8) {
-					uint8* pixel = (uint8*)gFr->inData;
-					uint16 rectHeight = (uint16)(inRect->bottom - inRect->top);
-					uint16 rectWidth = (uint16)(inRect->right - inRect->left);
-
-					for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++) {
-						Ptr dissolve = (char *)buf + bytesPerPixel * 
-							(imageWidth * (inRect->top + pixelY) + inRect->left) + plane;
-						for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++) {
-							*dissolve = *pixel++;
-							dissolve += bytesPerPixel;
-						}
-						pixel += gFr->inRowBytes - rectWidth;
-					}
-				} else {
-					// assume 16-bit
-					uint16* pixel = (uint16*)gFr->inData;
-					uint16 rectHeight = (uint16)(inRect->bottom - inRect->top);
-					uint16 rectWidth = (uint16)(inRect->right - inRect->left);
-					int bytesPerPixel2 = bytesPerPixel >> 1;
-
-					for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++) {
-						uint16 *dissolve = (uint16 *)((char *)buf + 
-							bytesPerPixel * 
-							(imageWidth * (inRect->top + pixelY) + inRect->left)
-							+ 2*plane);
-						for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++) {
-							// convert 0..32768 to 0..65535
-							*dissolve = (*pixel++ * 65535U + 16384U) >> 15;
-							dissolve += bytesPerPixel2;
-						}
-						pixel += (gFr->inRowBytes - 2*rectWidth) >> 1;
-					}				
-				}
-			}
-
-		}
-	}
-
-	return 0;
+  // loop through each tile makeing sure we don't go over the bounds
+  // of the imageHeight or imageWidth
+  for (uint16 vertTile = 0; vertTile < tilesVert; vertTile++)
+  {
+    for (uint16 horizTile = 0; horizTile < tilesHoriz; horizTile++)
+    {
+      inRect->top = (int16)(vertTile * tileHeight);
+      inRect->left = (int16)(horizTile * tileWidth);
+      inRect->bottom = (int16)(inRect->top + tileHeight);
+      inRect->right = (int16)(inRect->left + tileWidth);
+
+      if (inRect->bottom > imageHeight)
+        inRect->bottom = imageHeight;
+      if (inRect->right > imageWidth)
+        inRect->right = imageWidth;
+
+      for (uint16 plane = 0; plane < 3; plane++)
+      {
+        // we want one plane at a time, small memory foot print is good
+        gFr->inLoPlane = plane;
+        gFr->inHiPlane = plane;
+  
+        // update the gFr with our latest request
+        *gResult = gFr->advanceState();
+        if (*gResult != noErr) 
+        {
+          return display("cpyPsToBuf: advanceState");
+        }
+
+        // copy one channel at a time
+        if (imageDepth == 8)
+        {
+          uint8* pixel = (uint8*)gFr->inData;
+          uint16 rectHeight = (uint16)(inRect->bottom - inRect->top);
+          uint16 rectWidth = (uint16)(inRect->right - inRect->left);
+
+          for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++)
+          {
+            Ptr dissolve = (char *)buf + bytesPerPixel * 
+              (imageWidth * (inRect->top + pixelY) + inRect->left) + plane;
+            for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++)
+            {
+              *dissolve = *pixel++;
+              dissolve += bytesPerPixel;
+            }
+            pixel += gFr->inRowBytes - rectWidth;
+          }//pixelY
+        }//8 bit
+        else
+        {
+          // assume 16-bit
+          uint16* pixel = (uint16*)gFr->inData;
+          uint16 rectHeight = (uint16)(inRect->bottom - inRect->top);
+          uint16 rectWidth = (uint16)(inRect->right - inRect->left);
+          int bytesPerPixel2 = bytesPerPixel >> 1;
+
+          for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++)
+          {
+            uint16 *dissolve = (uint16 *)((char *)buf + 
+              bytesPerPixel * 
+              (imageWidth * (inRect->top + pixelY) + inRect->left)
+              + 2*plane);
+            for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++)
+            {
+              // convert 0..32768 to 0..65535
+              *dissolve = (*pixel++ * 65535U + 16384U) >> 15;
+              dissolve += bytesPerPixel2;
+            }
+            pixel += (gFr->inRowBytes - 2*rectWidth) >> 1;
+          }//pixelY
+        }//16 bit
+      }//plane
+    }//horizTile
+  }//vertTile
+
+  return 0;
 }

Get latest updates about Open Source Projects, Conferences and News.

Sign up for the SourceForge newsletter:

JavaScript is required for this form.





No, thanks