Exemplo n.º 1
0
			public void WriteLine (FloatMatrix matrix, int z, MatrixLine mask)
			{
				int start = (z-matrix.rect.offset.z)*matrix.rect.size.x - matrix.rect.offset.x   +  offset;
				for (int x=0; x<length; x++)
					matrix.arr[start+x] = arr[x] * mask.arr[x];  //matrix[x+offset, z];
					
			}
Exemplo n.º 2
0
			public static void SpreadBlur (ref MatrixLine curr, ref MatrixLine prev, int blur)
			{
				for (int x=0; x<curr.arr.Length; x++)
				{
					if (curr.arr[x] > 0.001f) continue;

					float val = 0;
					float sum = 0;

					if (prev.arr[x] > 0.001f)	 { val += prev.arr[x]; sum++; }

					for (int i=1; i<=blur; i++)
					{
						if (x-i >= 0  &&  prev.arr[x-i] > 0.001f)					{ val += prev.arr[x-i]; sum++; }
						if (x+i < prev.arr.Length-1  &&  prev.arr[x+i] > 0.001f)	{ val += prev.arr[x+i]; sum++; }
					}

					if (sum != 0)
						curr.arr[x] = val / sum;
				}

				//swapping lines
				MatrixLine tmp = prev;
				prev = curr;
				curr = tmp;
			}
Exemplo n.º 3
0
			public void DownsampleBlur (int downsample, float blur, MatrixLine tmpDownsized, MatrixLine tmpBlur)
			/// both temp lines length is length/downsample
			{
				ResampleLinear(this, tmpDownsized);
				tmpDownsized.GaussianBlur(tmpBlur.arr, blur);
				ResampleCubic(tmpDownsized, this);
			}
Exemplo n.º 4
0
			public void GaussianBlur (float[] tmp, float blur)
			{
				int iterations = (int)blur;

				MatrixLine src = new MatrixLine(arr, 0, length); //for switching arrays between iterations
				MatrixLine dst = new MatrixLine(tmp, 0, length);

				//iteration blur
				for (int i=0; i<iterations; i++)
				{
					for (int x=0; x<length; x++)
						dst.arr[x] = src.AverageSample(x);

					float[] t = src.arr;
					src.arr = dst.arr;
					dst.arr = t;
				}

				//last iteration - percentage
				float percent = blur - iterations;
				if (percent > 0.0001f)
				{
					for (int x=0; x<length; x++)
						dst.arr[x] = src.AverageSample(x)*percent + src.arr[x]*(1-percent);

					float[] t = src.arr;
					src.arr = dst.arr;
					dst.arr = t;
				}

				//copy values to arr for non-even iteration count
				for (int x=0; x<length; x++)
					dst.arr[x] = src.arr[x];
			}
Exemplo n.º 5
0
			public void Max (MatrixLine l) 
			{ 
				for (int i = 0; i<length; i++)
				{
					float v1 = arr[i];
					float v2 = l.arr[i];
					arr[i] = v1>v2 ? v1 : v2;
				}
			}
Exemplo n.º 6
0
			public static void ResampleCubic (MatrixLine src, MatrixLine dst)
			/// Scales the line filling dst with interpolated values. Cubic for upscale
			{
				for (int x=0; x<dst.length; x++)
				{
					float percent = 1.0f * x / dst.length;
					float sx = percent * src.length;
					dst.arr[x] = src.CubicSample(sx);
				}
			}
Exemplo n.º 7
0
			public static void DownsampleFast (MatrixLine src, MatrixLine dst, int ratio)
			/// Scales the line filling dst with interpolated values. Linear for downscale
			{
				for (int x=0; x<dst.length; x++)
				{
					float sumVal = 0;
					for (int ix=0; ix<ratio; ix++)
						sumVal += src.arr[x*ratio + ix];
					dst.arr[x] = sumVal / ratio;
				}
			}
Exemplo n.º 8
0
			public static void ResampleLinear (MatrixLine src, MatrixLine dst)
			/// Scales the line filling dst with interpolated values. Linear for downscale
			{
				float radius = 1.0f * src.length / dst.length;

				for (int x=0; x<dst.length; x++)
				{
					float percent = 1.0f * x / dst.length;
					float sx = percent * src.length;
					dst.arr[x] = src.LinearSample(sx, radius);
				}
			}
Exemplo n.º 9
0
			public void AppendRow (FloatMatrix matrix, int x, MatrixLine mask)
			{
				int start = (offset-matrix.rect.offset.z)*matrix.rect.size.x + x - matrix.rect.offset.x;
				for (int z=0; z<length; z++)
					matrix.arr[start + z*matrix.rect.size.x] += arr[z] * mask.arr[z];
			}
Exemplo n.º 10
0
			public void FillGapsOld (int start=0, int end=0, MatrixLine tmpFront=null, MatrixLine tmpBack=null, MatrixLine tmpFrontDist=null, MatrixLine tmpBackDist=null)
			{
				if (start==0 && end==0) end = length;

				if (tmpFront==null) tmpFront = new MatrixLine(offset, length);
				if (tmpBack==null) tmpBack = new MatrixLine(offset, length);
				if (tmpFrontDist==null) tmpFrontDist = new MatrixLine(offset, length);
				if (tmpBackDist==null) tmpBackDist = new MatrixLine(offset, length);

				//filling front line
				float prevVal = -1;
				float prevDist = 0;
				for (int x=start; x<end; x++)
				{
					float val = arr[x];
					if (val >= 0) 
					{
						prevVal = val;
						prevDist = 0;
					}

					tmpFront.arr[x] = prevVal;
					tmpFrontDist.arr[x] = prevDist;
					prevDist++;
				}

				//extended front line with delta vector - works fine but the result is so-so
				/*float prevVal = -1;
				float prevDist = 0;
				float prevDelta = 0;
				bool prevEnabled = false; //to avoid calculating delta on single pixels
				for (int x=0; x<length; x++)
				{
					float val = arr[x];
					if (val >= 0) 
					{
						prevDelta = val-prevVal;
						prevVal = val;
						prevDist = 0;

						if (!prevEnabled) 
						prevDelta = 0; //linear delta if prev pixel is a gap
						prevEnabled = true;
					}
					else
					{
						prevDist++;
						prevVal += prevDelta * (1f/prevDist);
					}

					tmpFront.arr[x] = prevVal;
					tmpFrontDist.arr[x] = prevDist;
				}*/

				//back line
				prevVal = -1;
				prevDist = 0;
				for (int x=end-1; x>=start; x--)
				{
					float val = arr[x];
					if (val >= 0) 
					{
						prevVal = val;
						prevDist = 0;
					}

					tmpBack.arr[x] = prevVal;
					tmpBackDist.arr[x] = prevDist;
					prevDist++;
				}

				//blending lines
				for (int x=start; x<end; x++)
				{
					//float val = arr[x];
					//if (val >= 0) continue;
					
					//float frontVal = tmpFront.arr[x];
					//float backVal = tmpBack.arr[x];

					float distSum = tmpFrontDist.arr[x] + tmpBackDist.arr[x];
					if (distSum == 0) continue;
					arr[x] = tmpFront.arr[x]*(tmpBackDist.arr[x]/distSum) + tmpBack.arr[x]*(tmpFrontDist.arr[x]/distSum); //note that front and back factors are inverted!
				}
			}