Image to Terminal glasses efficiency

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;

public class ImageToGlasses {

public static void main(String args[]) throws IOException {

//Horizontal size of a box with the same pixel colors
  int boxLeng = 1;

//Should it reboot once done writing to peripheral?
  boolean startupProgram = false;

//Current line of output file, resets every 21600 lines
  int currentLine = 0;

//Keep scanning down X for similar pixel color?
  boolean keepGoing = true;

//Previous color down X to test similar color
  int prevColor = 0;

//Number of files created
  int fileNo = 0;

//Output program
  String outputName = "outFile";

//Input PNG or JPG
  String fileName = "inImage.png";


  if(args.length == 1) {
   outputName = args[1];
   fileName = args[0];
  }else{
   System.out.println("Ex: java -jar ImageToGlasses.jar image.png outputLua");
  }


  File file = new File(fileName);
  BufferedImage image = ImageIO.read(file);

  Files.deleteIfExists(Paths.get(outputName));

  BufferedWriter writer = new BufferedWriter(new FileWriter(outputName, true));

//Write a header
  writer.append("g = peripheral.wrap(\"top\")\n");
  writer.append("function b(x,y,leng,hex,opacity)\n");
  writer.append("g.addBox(x,y,leng,1,hex,opacity)\n");
  writer.append("end\n");
  writer.append("g.clear()\n");

//Scan Left to right; Up to Down
  for (int y = 0; y < image.getHeight(); y++) {
   for (int x = 0; x < image.getWidth(); x++) {

	int clr = image.getRGB(x, y);
	int red = (clr &amp; 0x00ff0000) >> 16;
	int green = (clr &amp; 0x0000ff00) >> 8;
	int blue = clr &amp; 0x000000ff;
	int alpha = (clr &amp; 0xff000000) >>> 24;
	String hex = String.format("0x%02X%02X%02X", red, green, blue);

//Is the last pixel down X the same as the current one? If so extend length of box
	if (prevColor == clr) {

	 keepGoing = true;
	 for (int ex = x; ex < image.getWidth() &amp;&amp; keepGoing; ex++) {

	  if (image.getRGB(ex, y) == prevColor) {

	   boxLeng++;

	  } else {

	   keepGoing = false;

	  }
	 }
	}

	prevColor = clr;

//Use opacity if applicable, Prevents the writing of fully transparent pixels to save space
	if (((Integer) alpha).doubleValue() / 255.0 > 0.0) {

	 writer.append("b(" + x + "," + y + "," + boxLeng + "," + hex + "," + (((Integer) alpha).doubleValue() / 255.0) + ")\n");

	}
  
//When there are similar pixels start scanning X after the box
	if (boxLeng > 1) {

	 x = x + boxLeng - 1;

	}

	boxLeng = 1;

//Limit the file size, checks every 21600 lines to see if it's larger than ~500KB
	if (currentLine == 21600) {

	 boolean createNewFile = false;
	 currentLine = 0;
	 writer.close();

	 if (fileNo == 0) {

	  if (Files.size(Paths.get(outputName)) >= 300000) {

	   createNewFile = true;
	   writer = new BufferedWriter(new FileWriter(outputName, true));

	  } else {

	   writer = new BufferedWriter(new FileWriter(outputName, true));

	  }

	 } else {

	  if (Files.size(Paths.get(outputName + fileNo)) >= 300000) {

	   createNewFile = true;
	   writer = new BufferedWriter(new FileWriter(outputName + fileNo, true));

	  } else {

	   writer = new BufferedWriter(new FileWriter(outputName + fileNo, true));

	  }
	 }
	
//Check if file exceeded max size, closes writer and starts a new one
	 if (createNewFile) {

	  fileNo++;
	  writer.append("shell.run(\"paster run " + outputName + fileNo + "\")");
	  writer.close();
	  Files.deleteIfExists(Paths.get(outputName + fileNo));
	  writer = new BufferedWriter(new FileWriter(outputName + fileNo, true));

	  writer.append("g = peripheral.wrap(\"top\")\n");
	  writer.append("function b(x,y,leng,hex,opacity)\n");
	  writer.append("g.addBox(x,y,leng,1,hex,opacity)\n");
	  writer.append("end\n");

	 }
	}

	currentLine++;

   }
  }

//Add footer when done with current file
  writer.append("g.sync()\n");

  if (startupProgram) {
   writer.append("shell.run(\"startup\")");
  }

  writer.close();

}
}

if (((Integer) alpha).doubleValue() / 255.0 > 0.0) {

g = peripheral.wrap("top")
function b(x,y,leng,hex,opacity)
	g.addBox(x,y,leng,1,hex,opacity)
end

b(a,b,c,d,e)

local g = peripheral.wrap("top")
local b = g.addBox

b(a,b,c,1,d,e)

Spoiler

local function printf( fmt, ... )
	return print( fmt:format( ... ) )
end

local function timef( f, c, ... )
	local t = ccemux and ccemux.milliTime() or os.clock()
	for i = 1, c do
		f( ... )
	end
	return ccemux and (ccemux.milliTime() - t) / 1000 or os.clock() - t
end

g = {
	--# non-trivial function
	addBox = function() for i = 1, 100 do type{} end end
}

local count = 5000
local localAddBox = g.addBox

function b(x,y,leng,hex,opacity)
	g.addBox(x,y,leng,1,hex,opacity)
end

local timeGlobals = timef(b, count, 1, 2, 3, 4, 5)
local timeLocals = timef(localAddBox, count, 1, 2, 3, 100, 4, 5)

printf("Time for globals: %s", timeGlobals)
printf("Time for locals: %s", timeLocals)
printf("Performance ratio: %s", timeGlobals / timeLocals)

b(22,207,1,0x010101,1.0)
b(23,207,3,0x010101,1.0)

local glasses = peripheral.wrap("top")
local box = glasses.addBox

local myImgData = {
	{colStart, rowStart, {len1, col1, alpha1}, {len2, col2, alpha2}, etc},
	{colStart, rowStart, {len1, col1, alpha1}, {len2, col2, alpha2}, etc},
	etc
}

for i = 1, #myImgData do
	local thisLine = myImgData[i]
	local x, y = thisLine[1], thisLine[2]
	
	for i = 3, #thisLine do
		local thisBox = thisLine[i]
		if thisBox[3] > 0 then box(x, y, thisBox[1], 1, thisBox[2], thisBox[3]) end
		x = x + thisBox[1]
	end
end

Bomb Bloke, on 06 November 2017 - 03:04 AM said:

When searching for duped pixels, it'd be easier to look at the next color for matches, not the previous colour. If you really want to check the previous colour then you'll need to jump through a few hoops in order to avoid generating stuff like this within your output:

b(22,207,1,0x010101,1.0)
b(23,207,3,0x010101,1.0)

Checking for duped pixels in two dimensions might be a bit tricky, but it may not be too painful to perform an initial count-up to find the "most common colour" before you do your main draw. That colour can then be plonked down as one big box (assuming it doesn't turn out to be "full transparency"), effectively making it a "background".

You could stand to drop the precision on your alpha values a bit (just round to the nearest hundredth), and there's certainly no call for any "point zeroes". You could also ignore the lowest bit of your R/G/B values when doing comparisons - this probably wouldn't reduce visual quality by any noticeable amount, but it'd potentially save a lot of space.

The largest reduction would be to make your code just a little more complex. Instead of generating a million lines of function calls with nearly identical x/y co-ords baked into them, generate a table with just the raw data you need, then use a Lua loop structure to do the actual drawing. Eg:

Spoiler

local glasses = peripheral.wrap("top")
local box = glasses.addBox

local myImgData = {
	{colStart, rowStart, {len1, col1, alpha1}, {len2, col2, alpha2}, etc},
	{colStart, rowStart, {len1, col1, alpha1}, {len2, col2, alpha2}, etc},
	etc
}

for i = 1, #myImgData do
	local thisLine = myImgData[i]
	local x, y = thisLine[1], thisLine[2]
	
	for i = 3, #thisLine do
		local thisBox = thisLine[i]
		if thisBox[3] > 0 then box(x, y, thisBox[1], 1, thisBox[2], thisBox[3]) end
		x = x + thisBox[1]
	end
end

Really I don't see any great reason to duplicate the "executable code" within every single "data file" you produce, though. You could again get another large reduction in filesize by switching to a "binary" output format and keeping your "image drawing" script code in a single stand-alone file.

BBPack may be useful here. Entering "bbpack compress" at the command line, and then adding os.loadAPI("bbpack") to the top of your startup file, will typically allow you to store a lot more on your computers. You can likewise do "bbpack <URL> <localPath>" to create links to online sources from within your local filesystem, making it easy to work with files which're potentially much larger than what your drives could hold.

Bomb Bloke, on 08 November 2017 - 05:51 AM said:

That sounds… unlikely. I mean, yeah, direct calls will technically execute faster than ones requiring table lookups… but 120x faster? No, I'd say there was something very wrong with your implementation.

Bomb Bloke, on 13 November 2017 - 06:33 AM said:

The image data you've generated seems to be rendering correctly. The issue is in your (omitted) Java code: it's setting box[4] to 0 for each and every record.

(In cases where it should be set to 0, I personally wouldn't define it at all.)

Your duped pixel checker is also still broken, there are a lot of savings to be made by fixing that!

{0,187,{1,0xFF5000},{53,0xFF5000},{1,0xFF5000,0.2},{1},{106},{1,0x00AEEF},{145,0x00AEEF},{1},{169},{1,0x00FF00},{1,0x00FF00}},
English translation: Start line at X=0,Y=187. Add 1 colored box with a length of 0 then one after with a length of 52 then another after with a length of 1. Next add an empty space after for 106 pixels. E.t.c.

if #box == 3 then
b(x, y, box[1], box[2], box[3])
elseif(#box == 2) then
b(x, y, box[1], box[2], 1.0) -- Idea from calling out the repetitive 0s. Now every, very common, fully colored pixel no longer needs to be defined.
end
x = x + box[1]

if #box == 3 then
b(x, y, box[1], box[2], box[3])
elseif(#box == 2) then
b(x, y, box[1], box[2], 1.0) -- Idea from calling out the repetitive 0s. Now every, very common, fully colored pixel no longer needs to be defined.
end

b(x, y, box[1], box[2], box[3] or 1)

Bomb Bloke, on 15 November 2017 - 04:17 AM said:

File file = new File(fileName);
BufferedImage image = ImageIO.read(file);

Files.deleteIfExists(Paths.get(outputName));
FileOutputStream fileOut = new FileOutputStream(outputName);
BufferedOutputStream writer = new BufferedOutputStream(fileOut);

writer.write(1); //1 Volume (Future Implementation)
writer.write(image.getHeight() &  255);
writer.write((image.getHeight() >> 8) & 255);
writer.write(image.getWidth() & 255);
writer.write((image.getWidth() >> 8) & 255);

int[][] lengths = new int[image.getHeight()][image.getWidth()];
for (int y = 0; y < image.getHeight(); y++) {
for (int x = 0; x < image.getWidth(); x++) {
  int leng = 1;
  while (x + leng < image.getWidth() &amp;&amp; image.getRGB(x, y) == image.getRGB(x + leng, y)) {
   leng++;
  }
  lengths[y][x] = leng;
  x += leng - 1;
}
}

//Scan Left to right; Up to Down
for (int y = 0; y < image.getHeight(); y++) {
for (int x = 0; x < image.getWidth(); x++) {
  int clr = image.getRGB(x, y);
  int red = (clr &amp; 0x00ff0000) >> 16;
  int green = (clr &amp; 0x0000ff00) >> 8;
  int blue = clr &amp; 0x000000ff;
  int alpha = (clr &amp; 0xff000000) >>> 24;

  writer.write(lengths[y][x] &amp; 255);
  writer.write((lengths[y][x] >> 8) &amp;  255);
  writer.write(red);
  writer.write(green);
  writer.write(blue);
  writer.write(alpha);
}
}

local fileName = "input"
-- Glasses Bridge Side
local side = "top"
local g = peripheral.wrap(side)
local lastTime = os.clock()
local queueEvent = os.queueEvent
local pullEvent = os.pullEvent
local myEvent
local addBox = g.addBox
local sync = g.sync
local function b(x,y,leng,hex,opacity)
  addBox(x,y,leng,1,hex,opacity)
end
g.clear()
local input = fs.open(fileName, "rb")
local read = input.read
volumes = read()
local height = read() + read() * 256
local width = read() + read() * 256
local heighty
local widthy
for heighty=0, height-1 do
  for widthy=0, width-1 do
	--local r,g,b,a = input.read(),input.read(),input.read(),input.read()
	b(widthy,heighty,read() + read() * 256,((read()*65536)+(read()*256))+read(),read()*0.00392156863)
	myEvent = tostring({})
	queueEvent(myEvent)
	pullEvent(myEvent)
  end
end
print("T: "..os.clock()-lastTime) --Takes 53.3 seconds using a moderately intensive image
input.close()
g.sync()