Commit: afe595564995bffbc0c9f44e1b7e3a4e30f70c38 - lines (git)

line rasterizer test

Commit MetaInfo

• Revision: afe595564995bffbc0c9f44e1b7e3a4e30f70c38 (tree)
• Zeit: 2011-02-14 00:37:03
• Autor: beru <berupon@gmai...>
• Commiter: beru

Log Message

shift line rasterize algorithm

Ändern Zusammenfassung

• add: gl/lineDrawer8_Shift.h
• modified: lines.vcproj
• modified: main_plus.h
• delete: shift.cpp

Diff

--- /dev/null
+++ b/gl/lineDrawer8_Shift.h
@@ -0,0 +1,129 @@
+#pragma once
+
+#include <math.h>
+#include <algorithm>
+#include "buffer2d.h"
+#include "arrayutil.h"
+
+#include "ILineDrawer.h"
+
+namespace gl
+{
+
+template <typename NumericT, size_t slopeCorrectionTableSize = 256>
+class LineDrawer8_Shift : public IBufferLineDrawer<NumericT, uint8_t>
+{
+private:
+	Buffer2D<uint8_t>*	pBuff_;
+	
+	const NumericT* slopeCorrectionTable_;
+	
+	inline
+	void blend(
+		uint8_t* p,
+		NumericT v
+		)
+	{
+		uint8_t old = *p;
+		if (old != 0xff) {
+			NumericT nv = NumericT(old) + v;
+			*p = (nv >= NumericT(255.0)) ? 255 : halfAdjust(nv);
+		}
+	}
+
+public:
+
+	LineDrawer8_Shift()
+		:
+		slopeCorrectionTable_(NULL),
+		pBuff_(NULL)
+	{
+	}
+	
+	void SetSlopeCorrectionTable(const NumericT* slopeCorrectionTable)		{	slopeCorrectionTable_ = slopeCorrectionTable;	}
+	
+	void SetBuffer(Buffer2D<uint8_t>* pBuff)
+	{
+		pBuff_ = pBuff;
+	}
+	
+	void shift(const uint8_t* src, uint8_t* dst, size_t len, float offset)
+	{
+		assert(offset >= 0.0f);
+		float inversed = 1.0f - offset;
+		uint8_t part;
+		uint8_t remain = 0;
+		for (size_t i=0; i<len; ++i) {
+			part = src[i] * inversed;
+			dst[i] = part + remain;
+			remain = src[i] - part;
+		}
+		dst[len] = remain;
+	}
+	
+	void DrawLine(uint8_t intensity, NumericT x1, NumericT y1, NumericT x2, NumericT y2)
+	{
+		NumericT width = abs(x2 - x1);
+		NumericT height = abs(y2 - y1);
+		if (width + height == NumericT(0))
+			return;
+		assert(2 <= slopeCorrectionTableSize);
+		const int lineOffset = pBuff_->GetLineOffset();
+		
+		NumericT alpha = NumericT(intensity);
+		
+//		if (height < width) {
+		if (1) {
+			if (x2 < x1) { // left;
+				std::swap(x2, x1);
+				std::swap(y2, y1);
+			}
+			const NumericT dy = y2 - y1;
+			const NumericT gradient = dy / width;
+			float rotation = abs(width / dy);
+			
+			alpha *= slopeCorrectionTable_[ ToInt(mul<slopeCorrectionTableSize - 1>(abs(gradient))) ];
+			
+			uint8_t pat1[512] = {0};
+			uint8_t pat2[512+1];
+			
+			float patLen = rotation * 1.28;
+			patLen = std::min(256.0f, patLen);
+			int iPatLen = ceil(patLen);
+			for (size_t i=0; i<iPatLen; ++i) {
+				float x = (i * 2) / patLen;
+				float v = exp(- x * x);
+				pat1[iPatLen-i] = pat1[iPatLen+i] = (v * 255 + 0.5);
+			}
+			
+			uint8_t* ptr = (uint8_t*)pBuff_->GetPixelPtr(ToInt(x1)-2, ToInt(y1));
+			
+			const float offset = rotation;
+			float curOffset = 0;
+			float ylen = height;
+			for (size_t y=0; y<ylen; ++y) {
+				int io = (int) curOffset;
+				bool isMinus = curOffset < 0.0f;
+				float fracOffset = curOffset - io;
+				if (isMinus) {
+					fracOffset += 1.0f;
+					--io;
+				}
+				const size_t w = iPatLen * 2;
+				shift(pat1, pat2, w, fracOffset);
+				for (size_t x=0; x<w; ++x) {
+					ptr[io+x] = pat2[x];
+				}
+				OffsetPtr(ptr, lineOffset);
+				curOffset += offset;
+			}
+
+
+
+		}
+	}
+
+};
+
+} // namespace gl
+

--- a/lines.vcproj
+++ b/lines.vcproj
@@ -177,10 +177,6 @@
 				>
 			</File>
 			<File
-				RelativePath=".\shift.cpp"
-				>
-			</File>
-			<File
 				RelativePath=".\stdafx.cpp"
 				>
 				<FileConfiguration
@@ -329,6 +325,10 @@
 				>
 			</File>
 			<File
+				RelativePath=".\gl\lineDrawer8_Shift.h"
+				>
+			</File>
+			<File
 				RelativePath=".\gl\lineDrawer8_Wu.h"
 				>
 			</File>

--- a/main_plus.h
+++ b/main_plus.h
@@ -7,6 +7,7 @@
 #include "gl/lineDrawer8_DDA.h"
 #include "gl/lineDrawer8_Wu.h"
 #include "gl/lineDrawer8_Nelson.h"
+#include "gl/lineDrawer8_Shift.h"
 
 #include "shift.h"
 
@@ -22,8 +23,11 @@ gl::LineDrawer8_Bresenham<float> lineDrawer_Bresenham;
 gl::LineDrawer8_DDA<float> lineDrawer_DDA;
 gl::LineDrawer8_Wu<float> lineDrawer_Wu;
 gl::LineDrawer8_Nelson<float> lineDrawer_Nelson;
-float shiftX = 128;
-float shiftY = 1024;
+
+gl::LineDrawer8_Shift<float> lineDrawer_Shift;
+
+float shiftX = 512;
+float shiftY = 512;
 
 void renderLines(gl::IBufferLineDrawer<float, uint8_t>& ld, float x)
 {
@@ -31,11 +35,11 @@ void renderLines(gl::IBufferLineDrawer<float, uint8_t>& ld, float x)
 	float offset = 0;
 	for (int s=0; s<16; ++s) {
 		int slide = s * 120;
-		int ei = 25;
+		int ei = 21- s / 4;
 		for (int i=0; i<ei; ++i) {
 			int y = 30 + 40 * i;
 			ld.DrawLine(
-				220,
+				0xff,
 				x+slide, y,
 				x+100+slide, y+offset
 				);
@@ -48,7 +52,7 @@ void renderLines(gl::IBufferLineDrawer<float, uint8_t>& ld, float x)
 			rec.bottom = rec.top + 20;
 			_stprintf(str, _T("%.1f"), offset);
 			::DrawText(hMemDC, str, -1, &rec, DT_LEFT);
-			offset += 0.1;
+			offset += 1.0;
 		}
 	}
 }
@@ -72,6 +76,9 @@ void render(UINT vk, uint16_t repeatCount)
 	case 'N':
 		renderLines(lineDrawer_Nelson, 10);
 		break;
+	case 'S':
+		renderLines(lineDrawer_Shift, 10);
+		break;
 	case '1':
 	case VK_LEFT:
 	case VK_RIGHT:
@@ -100,7 +107,8 @@ void render(UINT vk, uint16_t repeatCount)
 				shiftY += offset;
 				break;
 			}
-			shiftTest(buff, shiftX, shiftY);
+			lineDrawer_Shift.SetBuffer(&buff);
+			lineDrawer_Shift.DrawLine(0xff, 400, 400, shiftX, shiftY);
 		}
 		break;
 	}
@@ -113,6 +121,7 @@ void OnKeyDown(WPARAM vk, LPARAM lparam)
 	case 'D':
 	case 'W':
 	case 'N':
+	case 'S':
 	case '1':
 	case VK_LEFT:
 	case VK_RIGHT:
@@ -211,6 +220,8 @@ void SetupDIB(HWND hWnd)
 	lineDrawer_Nelson.SetSlopeCorrectionTable(slopeCorrectionTable);
 	lineDrawer_Nelson.SetFilterTable(filterTable);
 
+	lineDrawer_Shift.SetSlopeCorrectionTable(slopeCorrectionTable);
+
 #else
 	hBMP = CreateDIB32(width, -height, bmi, pBits);
 #endif

--- a/shift.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "stdafx.h"
-
-#include "shift.h"
-
-#include "gl/fixed.h"
-
-void shift(const uint8_t* src, uint8_t* dst, size_t len, float offset)
-{
-	assert(offset >= 0.0f);
-	float inversed = 1.0f - offset;
-	uint8_t part;
-	uint8_t remain = 0;
-	for (size_t i=0; i<len; ++i) {
-		part = src[i] * inversed;
-		dst[i] = part + remain;
-		remain = src[i] - part;
-	}
-	dst[len] = remain;
-}
-
-void shiftTest(gl::Buffer2D<uint8_t>& buff, float shiftX, float shiftY)
-{
-	uint8_t pat1[256] = {0};
-	uint8_t pat2[256+1];
-	
-	float patLen = abs(shiftX / shiftY) * 2;
-	patLen = std::max(2.0f, patLen);
-	patLen = patLen * 2 + 1;
-	patLen = std::min(256.0f, patLen);
-	int iPatLen = patLen + 0.5;
-	for (size_t i=0; i<iPatLen/2; ++i) {
-		float x = i / (float)(iPatLen/4);
-		float v = exp(- x * x);
-		pat1[iPatLen/2-i] = pat1[iPatLen/2+i] = v * 255;
-	}
-	
-	const float offset = shiftX / shiftY;
-	float curOffset = 0;
-	float ylen = shiftY;
-	for (size_t y=0; y<ylen; ++y) {
-		int io = (int) curOffset;
-		bool isMinus = curOffset < 0.0f;
-		float fracOffset = curOffset - io;
-		if (isMinus) {
-			fracOffset += 1.0f;
-			--io;
-		}
-		shift(pat1, pat2, patLen, fracOffset);
-		for (size_t x=0; x<patLen; ++x) {
-			buff.SetPixel(600+x+io, 10+y, pat2[x]);
-		}
-		curOffset += offset;
-	}
-	
-}
-