View difference between Paste ID: RFPK8BWf and 7XAmsAbX

 --[[
  paintutils extra functions
  dis is a fuckin' beta you twat
  gonna add:
 	rotation
 	pixelation
 
  pastebin get 7XAmsAbX pue
  pastebin get RFPK8BWf puebeta
 
 list of extra functions:
  paintutils.flipY(table image)
 	returns 'image' stretched vertically
  paintutils.flipX(table image)
 	returns 'image' stretched horizontally
  paintutils.grayOut(table image)
 	converts 'image' to grayscale
  paintutils.lighten(table image)
 	returns 'image' but with brighter colors, suitable for transitions
  paintutils.darken(table image)
 	returns 'image' but with darker colors, suitable for transitions
  paintutils.getSize(table image)
 	returns the x and y sizes of 'image'
  paintutils.stretchImage(table image, number stretchedX, number stretchedY)
 	returns 'image', but stretched to fit sizes 'stretchedX' and 'stretchedY'.
  paintutils.merge(table {image1,x,y}, table {image2,x,y}, ...)
 	returns an image composed of image1 layered upon image2 layered upon image3 and so on.
  paintutils.fullScreen(number color, terminal object)
 	returns a fullscreen picture made solidly of 'color'. sets size to current terminal or 'object' if defined.
  paintutils.unloadImage(table image)
 	returns a string NFP picture made from 'image'.
  paintutils.autocrop(table image)
 	returns 'image' but with the blank space cut off from the left and top.
  paintutils.drawImageBlit(table image, number x, number y)
 	draws 'image' at 'x' and 'y' using term.blit. As such, it does not support transparency. You will want to merge images together before rendering.
  paintutils.drawImageBlitCenter(table image, number x, number y, terminal object)
  	draws 'image' centered around 'x' and 'y'. if 'x' and 'y' aren't defined, they default to half the screen width and height respectively. 'object' can be defined to use its screen size instead.
  paintutils.drawImageCenter(table image, number x, number y, terminal object)
 	same as drawImageBlitCenter, but with the normal paintutils.drawImage. 'object' can be defined to use its screen size instead.
  paintutils.centerWithBlankSpace(table image, number x, number y, terminal object)
 	returns 'image', but with extra blank space to center it to 'x' and 'y'. if 'x' and 'y' aren't defined, they default to half the screen width and height respectively. 'object' can be defined to use its screen size instead.
 --]]
 
 local round = function(x) return x + 0.5 - (x + 0.5) % 1 end
 local deepCopy = function(tbl) return {table.unpack(tbl)} end
 local bcol, ccol = {
 [0]=" ",[colors.white]="0",[colors.orange]="1",[colors.magenta]="2",[colors.lightBlue]="3",[colors.yellow]="4",[colors.lime]="5",[colors.pink]="6",[colors.gray]="7",[colors.lightGray]="8",[colors.cyan]="9",[colors.purple]="a",[colors.blue]="b",[colors.brown]="c",[colors.green]="d",[colors.red]="e",[colors.black]="f"}, {}
 for k,v in pairs(bcol) do ccol[v] = k end
 
 paintutils.flipY = function(image)
 	local output = {}
 	for y = #image, 1, -1 do output[#output+1] = image[y] end
 	return output
 end
 
 paintutils.flipX = function(image)
 	local output,sizeX = {}, 0
 	for y = 1, #image do sizeX = math.max(sizeX,#image[y]) end
 	for y = 1, #image do
 		output[y] = {}
 		for x = 1, sizeX do output[y][x] = deepCopy(image)[y][sizeX-(x-1)] or 0 end
 	end
 	return output
 end
 
 paintutils.grayOut = function(image)
 	local output,grays = {},{[0] = 0,[colors.white]=colors.white,[colors.orange]=colors.lightGray,[colors.magenta]=colors.lightGray,[colors.lightBlue]=colors.lightGray,[colors.yellow]=colors.white,[colors.lime]=colors.lightGray,[colors.pink]=colors.lightGray,[colors.gray]=colors.gray,[colors.lightGray]=colors.lightGray,[colors.cyan]=colors.lightGray,[colors.purple]=colors.gray,[colors.blue]=colors.gray,[colors.brown]=colors.gray,[colors.green]=colors.lightGray,[colors.red]=colors.gray,[colors.black]=colors.black}
 	for y = 1, #image do
 		output[y] = {}
 		for x = 1, #image[y] do output[y][x] = grays[image[y][x]] or image[y][x] end
 	end
 	return output
 end
 
 paintutils.lighten = function(image)
 	local output,lighters = {},{[0] = 0,[colors.white] = colors.white,[colors.orange] = colors.yellow,[colors.magenta] = colors.pink,[colors.lightBlue] = colors.white,[colors.yellow] = colors.white,[colors.lime] = colors.white,[colors.pink] = colors.white,[colors.gray] = colors.lightGray,[colors.lightGray] = colors.white,[colors.cyan] = colors.lightBlue,[colors.purple] = colors.magenta,[colors.blue] = colors.lightBlue,[colors.brown] = colors.orange,[colors.green] = colors.lime,[colors.red] = colors.magenta,[colors.black] = colors.gray}
 	for y = 1, #image do
 		output[y] = {}
 		for x = 1, #image[y] do output[y][x] = lighters[image[y][x]] or image[y][x] end
 	end
 	return output
 end
 
 paintutils.darken = function(image)
 	local output, darkers = {},{[0]=0,[colors.white]=colors.lightGray,[colors.orange]=colors.brown,[colors.magenta]=colors.purple,[colors.lightBlue]=colors.cyan,[colors.yellow]=colors.orange,[colors.lime]=colors.green,[colors.pink]=colors.magenta,[colors.gray]=colors.black,[colors.lightGray]=colors.gray,[colors.cyan]=colors.blue,[colors.purple]=colors.gray,[colors.blue]=colors.gray,[colors.brown]=colors.black,[colors.green]=colors.gray,[colors.red]=colors.gray,[colors.black]=colors.black}
 	for y = 1, #image do
 		output[y] = {}
 		for x = 1, #image[y] do output[y][x] = darkers[image[y][x]] or image[y][x] end
 	end
 	return output
 end
 
 paintutils.getSize = function(image)
 	local xsize = 0
 	if type(image) ~= "table" then return 0,0 end
 	for y = 1, #image do xsize = math.max(xsize,#image[y]) end
 	return xsize, #image
 end
 
 paintutils.stretchImage = function(_image,sx,sy)
 	local image,output = deepCopy(_image), {}
 	if sx == 0 or sy == 0 then return {{}} end
 	if sx < 0 then image = paintutils.flipX(image) end
 	if sy < 0 then image = paintutils.flipY(image) end
 	sx,sy = round(math.abs(sx)), round(math.abs(sy))
 	if sx == 0 or sy == 0 then return {{}} end
 	local imX,imY = paintutils.getSize(image)
 	local xcur,ycur
 	for y = 1, sy do
 		output[y] = {}
 		for x = 1, sx do
 			output[y][x] = image[math.max(1,round((y/sy)*imY))][math.max(1,round((x/sx)*imX))] or nil
 		end
 	end
 	return output
 end
 
 paintutils.drawImageBlit = function(image,ix,iy,object)
 	if (type(image) ~= "table") or (type(ix) ~= "number") or (type(iy) ~= "number") then
 		error("Expected image, x, y", 2)
 	else
 		object = object or term
 		ix, iy = round(ix), round(iy)
 		local buff
 		for y = 1, #image do
 			buff = ""
 			for x = 1, #image[y] do
 				buff = buff..bcol[image[y][x]]
 			end
 			object.setCursorPos(ix,iy+(y-1))
 			object.blit(buff,buff,buff)
 		end
 	end
 end
 
 paintutils.drawImage = function(image,ix,iy,object)
 	if (type(image) ~= "table") or (type(ix) ~= "number") or (type(iy) ~= "number") then
 		error("Expected image, x, y", 2)
 	else
 		object = object or term
 		for y = 1, #image do
 			object.setCursorPos(ix,iy+(y-1))
 			for x = 1, #image[y] do
 				if image[y][x] == 0 then
 					object.setCursorPos(ix+x,iy+(y-1))
 				else
 					object.blit(" ","0",bcol[image[y][x]])
 					if x == #image[y] and y == #image then --gotta have that backwards compatibility
 						object.setBackgroundColor(image[y][x])
 					end
 				end
 			end
 		end
 	end
 end
 
 paintutils.centerWithBlankSpace = function(_image,ix,iy,object)
 	local image,scX,scY = deepCopy(_image)
 	if object then scX,scY = object.getSize() else scX,scY = term.getSize() end
 	local imgXsize,imgYsize = paintutils.getSize(image)
 	if imgXsize == 0 or imgYsize == 0 then return {{}} end
 	local incX,incY = math.floor((ix or (scX/2)) - (imgXsize/2)), math.floor((iy or (scY/2)) - (imgYsize/2))
 	local output = {}
 	for y = 1, imgYsize + incY do
 		output[y] = {}
 		for x = 1, imgXsize + incX do
 			if (x > incX) and (y > incY) then
 				output[y][x] = image[y-incY][x-incX] or 0
 			else
 				output[y][x] = 0
 			end
 		end
 	end
 	return output
 end
 
 paintutils.drawImageBlitCenter = function(image,ix,iy,object)
 	local scX,scY
 	object = object or term
 	if object then scX,scY = object.getSize() else scX,scY = term.getSize() end
 	local imgXsize,imgYsize = paintutils.getSize(image)
 	return paintutils.drawImageBlit(image, (ix or (scX/2)) - (imgXsize/2), (iy or (scY/2)) - (imgYsize/2), object)
 end
 
 paintutils.drawImageCenter = function(image,ix,iy,object)
 	local scX,scY
 	object = object or term
 	scX,scY = object.getSize()
 	local imgXsize,imgYsize = paintutils.getSize(image)
 	return paintutils.drawImage(image, (ix or (scX/2)) - (imgXsize/2), (iy or (scY/2)) - (imgYsize/2), object)
 end
 
 paintutils.merge = function(...)
 	local output,arg,imgXsize,imgYsize,image,xdiff,ydiff = {}, table.pack(...), 0, 0
 	for a = 1, #arg do
 		local x,y = paintutils.getSize(arg[a][1])
 		if not (x == 0 or y == 0) then
 			x, y = x+arg[a][2], y+arg[a][3]
 			imgXsize = math.max(imgXsize,x)
 			imgYsize = math.max(imgYsize,y)
 		end
 	end
 	for a = #arg, 1, -1 do
 		image,xdiff,ydiff = table.unpack(arg[a])
 		xdiff, ydiff = xdiff - 1, ydiff - 1
 		for y = 1, imgYsize do
 			output[y] = output[y] or {}
 			for x = 1, imgXsize do
 				output[y][x] = output[y][x] or 0
 				if image[y-ydiff] then
 					if image[y-ydiff][x-xdiff] and (image[y-ydiff][x-xdiff] ~= 0) then
 						output[y][x] = image[y-ydiff][x-xdiff]
 					end
 				end
 			end
 		end
 	end
 	return output
 end
 
 paintutils.fullScreen = function(bgcol,object)
 	local scr_x,scr_y = (object or term).getSize()
 	local output,l = {},{}
 	bgcol = bgcol or colors.black
 	for x = 1, scr_x do l[x] = bgcol end
 	for y = 1, scr_y do output[y] = l end
 	return output
 end
 
 paintutils.unloadImage = function(image)
 	local output = ""
 	for y = 1, #image do
 		for x = 1, #image[y] do output = output..bcol[image[y][x]] end
 		if y < #image then output = output.."\n" end
 	end
 	return output
 end
 
 paintutils.autocrop = function(image)
 	local output,top,leftings = {},1,{}
 	local isTopped = false
 	for a = 1, #image do
 		if (not isTopped) and (#image[a] > 0) then
 			top = a
 			isTopped = true
 		end
 		if isTopped then
 			output[#output+1] = deepCopy(image[a])
 		end
 	end
 	for y = 1, #output do
 		leftings[y] = 0
 		for x = 1, #output[y] do
 			if (output[y][x] == 0) or (output[y][x] == nil) then
 				leftings[y] = leftings[y] + 1
 			else
 				break
 			end
 		end
 	end
 	local left = math.min(table.unpack(leftings))
 	for y = 1, #output do
 		for l = 1, left do table.remove(output[y],1) end
 	end
 	return output
 end
 
 paintutils.rotateImage = function(image,degrees,centerX,centerY)
 	local imgXsize, imgYsize = paintutils.getSize(image)
 	centerX, centerY = centerX or imgXsize/2, centerY or imgYsize/2
 	degrees = math.rad(degrees)
 	local rotatePoint = function(x,y,degrees,centerX,centerY)
 		return ((x-centerX)*math.cos(degrees)) + ((y-centerY)*math.sin(degrees)), ((y-centerY)*math.cos(degrees)) - ((x-centerX)*math.sin(degrees))
 	end
 	local output = {}
 	local newXsize, newYsize = 0, 0
 	local minXsize, minYsize = 1, 1
 	local points = {
 		{rotatePoint(1,			1,			degrees,centerX,centerY)},
 		{rotatePoint(imgXsize,	1,			degrees,centerX,centerY)},
 		{rotatePoint(1,			imgYsize,	degrees,centerX,centerY)},
 		{rotatePoint(imgXsize,	imgYsize,	degrees,centerX,centerY)}
 	}
 	for a = 1, #points do
 		newXsize = math.ceil( math.max(newXsize,points[a][1]))
 		newYsize = math.ceil( math.max(newYsize,points[a][2]))
 		minXsize = math.floor(math.min(minXsize,points[a][1]))
 		minYsize = math.floor(math.min(minYsize,points[a][2]))
 	end
 	for y = 1, newYsize - (minYsize - 1) do
 		output[y] = {}
 		for x = 1, newXsize - (minXsize - 1) do
 			local rx,ry = rotatePoint(x + (minXsize - 1),y + (minYsize - 1),degrees,centerX,centerY)
 			rx, ry = round(rx), round(ry)
 			if image[ry] then
 				output[y][x] = image[ry][rx] or 0
 			end
 		end
 	end
 	return output
 end
 
 paintutils.pixelateImage = function(image,intensity)
 	local imgXsize, imgYsize = paintutils.getSize(image)
 	local output = {}
 	for y = 1, imgYsize do
 		output[y] = {}
 		for x = 1, imgXsize do
 			local vx, vy = math.max(math.min(round(x/intensity)*intensity,imgXsize),1), math.max(math.min(round(y/intensity)*intensity,imgYsize),1)
 			if image[vy] then
 				if image[vy][vx] then
 					output[y][x] = image[vy][vx]
 				else
 					output[y][x] = 0
 				end
 			else
 				output[y][x] = 0
 			end
 		end
 	end
 	return output
 end