Here's the second of our three sketches in Processing. Open another new window and paste this code into it, then save it as ConvertBMPto8bit.
// ConvertBMPto8bit - Read and enlarge a modified 32x24 24-bit gray BMP file,
// write an upscaled 256x192 BMP image with a 256 color table.
// Ver. 2 - Fetch filenames and convert all suitable BMPs we find.
// Builds sequences suitable for online animated GIF converters
import java.util.Date;
// BMP File Header, little end first
int BmpPSPHead[] = {
0x42, 0x4D, // "BM" in hex
0x36, 0xC4, 0x00, 0x00, // File size, 50230
0x00, 0x00, // reserved for app data 1
0x00, 0x00, // reserved for app data 2
0x36, 0x04, 0x00, 0x00 // Offset of pixel 0, 1078
};
// BMP 8-bit DIB Header, little end first
int DIBHeadPSP1[] = {
0x28, 0x00, 0x00, 0x00, // Header size, 40
0x00, 0x01, 0x00, 0x00, // pixel width, 256
0xC0, 0x00, 0x00, 0x00, // pixel height, 192
0x01, 0x00, // color planes, 1
0x08, 0x00, // bits per pixel, 8
0x00, 0x00, 0x00, 0x00, // Compression method, 0==none
0x00, 0x00, 0x00, 0x00, // Raw bitmap data size, dummy 0
0x12, 0x0B, 0x00, 0x00, // Pixels per meter H, 2834
0x12, 0x0B, 0x00, 0x00, // Pixels per meter V, 2834
0x00, 0x00, 0x00, 0x00, // Colors in palette, 0==default 2^n
0x00, 0x00, 0x00, 0x00 // Number of important colors, 0
};
byte outBytes[], b[]; // Buffer for the input file bytes
PImage img; // Declare variable of type PImage
int fileCount = 0, imageIndex = 0;
String[] filenames;
// "paletteChoice" selects a false color palette:
// 0 == Grayscale, white hot
// 1 == Ironbow
// 2 == Firebow
// 3 == Hot alarm
// 4 == Grayscale, black hot
int paletteChoice = 1;
void setup() {
int i, j, x, y;
String nameHead, nameTail;
size(256, 192); // Size must be the first statement
// noStroke();
frameRate(5);
background(0); // Clear the screen with a black background
outBytes = new byte[50230]; // 54 header + 1K colors + 12K pixels
String path = sketchPath() + "/data"; // Read from the "/data" subdirectory
println("Listing filenames: ");
filenames = listFileNames(path);
println(filenames);
fileCount = filenames.length;
println(fileCount + " entries");
if(fileCount < 1) {
println("No images found. Stopping.");
} else { // Filenames exist in the directory
for(i = 0; i < fileCount; ++i) { // Test each name
nameHead = filenames[i].substring(0, 3);
nameTail = filenames[i].substring(8);
j = int(filenames[i].substring(3, 8));
if(nameHead.equals("frm") && nameTail.equals(".bmp") && j != 0) // Source "frm_____.bmp" found?
enlarge8bit(i); // Process and write an enlarged 8-bit version
}
}
noLoop();
}
void draw() {
int countX, countY;
noSmooth();
for(countY = 0; countY < 192; ++countY) {
for(countX = 0; countX < 256; ++countX) {
stroke(0xFF & outBytes[1078 + (countY * 256 + countX)]); // Color from BMP buffer
point(countX, 191 - countY); // Draw a pixel, bottom up
}
}
}
void enlarge8bit(int fileNumber) { // Read a small gray "frm" BMP image and write an enlarged colormapped "out" BMP
int i, x, y;
b = loadBytes(filenames[fileNumber]); // Open a file and read its 8-bit data
for(i = 0; i < 14; ++i)
outBytes[i] = byte(BmpPSPHead[i] & 0xFF); // Copy BMP header 1 into output buffer
for(i = 0; i < 40; ++i)
outBytes[i + 14] = byte(DIBHeadPSP1[i] & 0xFF); // Copy header 2
loadColorTable(paletteChoice, 54); // Load color table, 54 byte BMP header offset
for(y = 0; y < 23; ++y) { // Bilinear interpolation, count the source pixels less one
for(x = 0; x < 31; ++x) {
for(int yLirp = 0; yLirp < 9; ++yLirp) {
int corner0 = b[54 + ((32 * y + x) + 32) * 3] & 0xFF;
int corner1 = b[54 + ((32 * y + x) + 0) * 3] & 0xFF;
int pixLeft = (corner0 * yLirp + corner1 * (8 - yLirp)) >> 3; // Lirp 1 endpoint from 2 L pixels,
int corner2 = b[54 + ((32 * y + x) + 33) * 3] & 0xFF;
int corner3 = b[54 + ((32 * y + x) + 1) * 3] & 0xFF;
int pixRight = (corner2 * yLirp + corner3 * (8 - yLirp)) >> 3; // and the other from 2 R pixels
for(int xLirp = 0; xLirp < 9; ++xLirp) {
int pixMid = (pixRight * xLirp + pixLeft * (8 - xLirp)) >> 3; // Lirp between lirped endpoints, bilinear interp
outBytes[1078 + y * 2048 + x * 8 + yLirp * 256 + xLirp + 771] = byte(pixMid & 0xFF);
}
}
}
}
for(y = 0; y < 192; ++y) { // Pad out the empty side pixels
for(x = 0; x < 4; ++x) {
outBytes[1078 + (3 - x) + 256 * y] = outBytes[1082 + 256 * y];
outBytes[1330 + x + 256 * y] = outBytes[1329 + 256 * y];
}
}
for(x = 0; x < 256; ++x) { // Pad out the empty above/below pixels
for(y = 0; y < 4; ++y) {
outBytes[ 1078 + 256 * (3 - y) + x] = outBytes[ 2102 + x];
outBytes[49206 + 256 * y + x] = outBytes[48950 + x];
}
}
saveBytes("data/out" + filenames[fileNumber].substring(3), outBytes); // Save a recolored 8-bit BMP as "out_____.bmp"
}
void loadColorTable(int choiceNum, int offset) {
int i, x;
switch(choiceNum) {
case 1: // Load 8-bit BMP color table with computed ironbow curves
for(x = 0; x < 256; ++x) {
float fleX = (float)x / 255.0;
float fleG = 255.9 * (1.02 - (fleX - 0.72) * (fleX - 0.72) * 1.96);
fleG = (fleG > 255.0) || (fleX > 0.75) ? 255.0 : fleG; // Truncate curve
i = (int)fleG;
outBytes[offset + x * 4 + 2] = byte(i & 0xFF); // Red vals
fleG = fleX * fleX * 255.9;
i = (int)fleG;
outBytes[offset + x * 4 + 1] = byte(i & 0xFF); // Grn vals
fleG = 255.9 * (14.0 * (fleX * fleX * fleX) - 20.0 * (fleX * fleX) + 7.0 * fleX);
fleG = fleG < 0.0 ? 0.0 : fleG; // Truncate curve
i = (int)fleG;
outBytes[offset + x * 4 + 0] = byte(i & 0xFF); // Blu vals
}
break;
case 2: // Compute quadratic "firebow" palette
for(x = 0; x < 256; ++x) {
float fleX = (float)x / 255.0;
float fleG = 255.9 * (1.00 - (fleX - 1.0) * (fleX - 1.0));
i = (int)fleG;
outBytes[offset + x * 4 + 2] = byte(i & 0xFF); // Red vals
fleG = fleX < 0.25 ? 0.0 : (fleX - 0.25) * 1.3333 * 255.9;
i = (int)fleG;
outBytes[offset + x * 4 + 1] = byte(i & 0xFF); // Grn vals
fleG = fleX < 0.5 ? 0.0 : (fleX - 0.5) * (fleX - 0.5) * 1023.9;
i = (int)fleG;
outBytes[offset + x * 4 + 0] = byte(i & 0xFF); // Blu vals
}
break;
case 3: // Compute "alarm" palette
for(x = 0; x < 256; ++x) {
float fleX = (float)x / 255.0;
float fleG = 255.9 * (fleX < 0.875 ? 1.00 - (fleX * 1.1428) : 1.0);
i = (int)fleG;
outBytes[offset + x * 4 + 2] = byte(i & 0xFF); // Red vals
fleG = 255.9 * (fleX < 0.875 ? 1.00 - (fleX * 1.1428) : (fleX - 0.875) * 8.0);
i = (int)fleG;
outBytes[offset + x * 4 + 1] = byte(i & 0xFF); // Grn vals
fleG = 255.9 * (fleX < 0.875 ? 1.00 - (fleX * 1.1428) : 0.0);
i = (int)fleG;
outBytes[offset + x * 4 + 0] = byte(i & 0xFF); // Blu vals
}
break;
case 4: // Grayscale, black hot
for(x = 0; x < 256; ++x) {
outBytes[offset + x * 4 + 2] = byte(255 - x & 0xFF); // Red vals
outBytes[offset + x * 4 + 1] = byte(255 - x & 0xFF); // Grn vals
outBytes[offset + x * 4 + 0] = byte(255 - x & 0xFF); // Blu vals
}
break;
default: // Grayscale, white hot
for(x = 0; x < 256; ++x) {
outBytes[offset + x * 4 + 2] = byte(x & 0xFF); // Red vals
outBytes[offset + x * 4 + 1] = byte(x & 0xFF); // Grn vals
outBytes[offset + x * 4 + 0] = byte(x & 0xFF); // Blu vals
}
}
}
String[] listFileNames(String dir) { // Return the filenames from a directory as an array of Strings
File file = new File(dir);
if (file.isDirectory()) {
String names[] = file.list();
return names;
} else // It's not a directory
return null;
}
Sketch 3: ConvertBMPtoSeq01
Just one more sketch to go! Do the same as before, saving this code as another new sketch named ConvertBMPtoSeq01.
// ConvertBMPtoSeq01 - Read and enlarge a modified 32x24 24-bit gray BMP file,
// saving 256x192 BMP images in 256 colors for converting to MOV.
// Ver. 1 - Fetch filenames and scan all suitable BMPs we find for their time/temp data,
// to set the scale for graphing these numbers through the MOV.
import java.util.Date;
byte colorPal[], b[]; // Buffers for a color palette, and reading bytes from files
PImage img;
int i, fileCount = 0, frameTotal = 0, earlyFrame = 0, lastFrame = 0,
hotLowFrame, hotHighFrame, coldLowFrame, coldHighFrame, targLowFrame, targHighFrame,
framX1, framX2, coldY1, coldY2, targY1, targY2, hotY1, hotY2,
offsetX = 153, offsetY = 6, numbersX = 40, numbersY = 30, graphX = 8, graphY = 342,
histoX = 410, histoY = 342, histoH = 140, histoW = 64, BGcolor = 48;
float hottestLow, hottestHigh, coldestLow, coldestHigh, targetLow, targetHigh;
String[] filenames;
// Change the following values to customize the output images.
// "paletteChoice" selects a false color palette:
// 0 == Grayscale, white hot
// 1 == Ironbow
// 2 == Firebow
// 3 == Hot alarm
// 4 == Grayscale, black hot
int paletteChoice = 1;
boolean markersVisible = true, celsiusFlag = false, lirpSmoothing = true;
void setup() {
int x, y;
float fixedPoint[];
String nameHead, nameTail;
size(480, 360); // Size must be the first statement
background(BGcolor); // Clear the screen with a gray background
noSmooth();
colorPal = new byte[1024]; // Reserve a 1K color table
loadColorTable(paletteChoice, 0); // Load color table
fixedPoint = new float[5]; // Buffer for added fixed point values
String path = sketchPath() + "/data"; // Read from the "/data" subdirectory
// println("Listing filenames: ");
filenames = listFileNames(path);
// println(filenames);
fileCount = filenames.length;
// println(fileCount + " entries");
if(fileCount < 1) {
println("No images found. Stopping.");
} else { // Filenames exist in the directory, convert what we can
// First pass: Read the embedded times/temps and find maxes/mins for graphing
print("Counting through files: ");
for(i = 0; i < fileCount; ++i) { // Test each filename for conformity
if((i & 0x3F) == 0)
print(i + ", ");
nameHead = filenames[i].substring(0, 3);
nameTail = filenames[i].substring(8);
if(nameHead.equals("frm") && nameTail.equals(".bmp") && int(filenames[i].substring(3, 8)) != 0) { // Source "frm_____.bmp" found?
b = loadBytes(filenames[i]); // Open a file and read its 8-bit data
for(x = 0; x < 5; ++x) { // Rebuild float values from next 4*n bytes in the file
fixedPoint[x] = expandFloat(b[2360 + (x * 4) + 0], b[2360 + (x * 4) + 1],
b[2360 + (x * 4) + 2], b[2360 + (x * 4) + 3]); // 2360 == headers + pixels + 2
}
y = ((b[2387] & 0xff) << 24) + ((b[2386] & 0xff) << 16)
+ ((b[2385] & 0xff) << 8) + (b[2384] & 0xff); // Reassemble a uint32_t millis() stamp
if(++frameTotal == 1) { // First frame found so far?
coldestLow = coldestHigh = fixedPoint[0];
targetLow = targetHigh = fixedPoint[2]; // Initialize all values
hottestLow = hottestHigh = fixedPoint[4];
hotLowFrame = hotHighFrame = coldLowFrame = coldHighFrame = targLowFrame = targHighFrame = earlyFrame = lastFrame = y;
} else { // Compare everything, update where necessary
if(y < earlyFrame)
earlyFrame = y; // These will set the left and right bounds
else if(y > lastFrame) // of the temperature over time graphs
lastFrame = y;
if(fixedPoint[0] < coldestLow) { // These will define the high and low bounds
coldestLow = fixedPoint[0];
coldLowFrame = y;
} else if(fixedPoint[0] > coldestHigh) {
coldestHigh = fixedPoint[0];
coldHighFrame = y;
}
if(fixedPoint[2] < targetLow) {
targetLow = fixedPoint[2];
targLowFrame = y;
} else if(fixedPoint[2] > targetHigh) {
targetHigh = fixedPoint[2];
targHighFrame = y;
}
if(fixedPoint[4] < hottestLow) {
hottestLow = fixedPoint[4];
hotLowFrame = y;
} else if(fixedPoint[4] > hottestHigh) {
hottestHigh = fixedPoint[4];
hotHighFrame = y;
}
}
}
}
println(i + ", done.\n");
// The high and low points of three datasets are found, display them
println("Frame times " + earlyFrame + " to " + lastFrame + " totaling " + (lastFrame - earlyFrame));
println("Cold values " + coldestLow + " at " + coldLowFrame + " to " + coldestHigh + " at " + coldHighFrame);
println("Targ values " + targetLow + " at " + targLowFrame + " to " + targetHigh + " at " + targHighFrame);
println("Hot values " + hottestLow + " at " + hotLowFrame + " to " + hottestHigh + " at " + hotHighFrame);
stroke(BGcolor + 48);
for(y = 0; y <= 140; y += 35)
line(graphX, graphY - y, graphX + 400, graphY - y); // Draw a generic grid for the time graph
for(x = 0; x <= 400; x += 40)
line(graphX + x, graphY - 140, graphX + x, graphY);
noStroke(); // Text labels for the top & bottom temp values of the graph
textSize(10);
fill(255);
if(celsiusFlag) {
text(hottestHigh, graphX + 402, graphY - 142);
text(coldestLow, graphX + 402, graphY + 12);
} else {
text(hottestHigh * 1.8 + 32.0, graphX + 402, graphY - 142);
text(coldestLow * 1.8 + 32.0, graphX + 402, graphY + 12);
}
fill(BGcolor + 128); // Predraw 6 little high/low markers in the graph space
rect(graphX + 400 * (coldLowFrame - earlyFrame) / (lastFrame - earlyFrame) - 1,
graphY - int((coldestLow - coldestLow) / (coldestLow - hottestHigh) * 140.0) - 1, 3, 3);
rect(graphX + 400 * (coldHighFrame - earlyFrame) / (lastFrame - earlyFrame) - 1,
graphY - int((coldestLow - coldestHigh) / (coldestLow - hottestHigh) * 140.0) - 1, 3, 3);
rect(graphX + 400 * (targLowFrame - earlyFrame) / (lastFrame - earlyFrame) - 1,
graphY - int((coldestLow - targetLow) / (coldestLow - hottestHigh) * 140.0) - 1, 3, 3);
rect(graphX + 400 * (targHighFrame - earlyFrame) / (lastFrame - earlyFrame) - 1,
graphY - int((coldestLow - targetHigh) / (coldestLow - hottestHigh) * 140.0) - 1, 3, 3);
rect(graphX + 400 * (hotLowFrame - earlyFrame) / (lastFrame - earlyFrame) - 1,
graphY - int((coldestLow - hottestLow) / (coldestLow - hottestHigh) * 140.0) - 1, 3, 3);
rect(graphX + 400 * (hotHighFrame - earlyFrame) / (lastFrame - earlyFrame) - 1,
graphY - int((coldestLow - hottestHigh) / (coldestLow - hottestHigh) * 140.0) - 1, 3, 3);
}
i = 0;
}
// Second pass: Read each frame again, plot color mapped enlarged image, temperature values and graph, save each frame
void draw() {
int x, y, histogram[];
float tempY, fixedPoint[];
String nameHead, nameTail;
noSmooth();
fixedPoint = new float[5]; // Buffer for appended fixed point values
histogram = new int[256]; // Buffer for color histogram
for(x = 0; x < 256; ++x)
histogram[x] = 0; // Initialize histogram
if(i < fileCount) { // Test each filename for conformity
nameHead = filenames[i].substring(0, 3);
nameTail = filenames[i].substring(8);
if(nameHead.equals("frm") && nameTail.equals(".bmp") && int(filenames[i].substring(3, 8)) != 0) { // Source "frm_____.bmp" found?
b = loadBytes(filenames[i]); // Open a file and read its 8-bit data
// println(i + " " + filenames[i]);
enlarge8bitColor(); // Place colored enlarged image on screen
for(x = 0; x < 5; ++x) { // Rebuild float values from next 4*n bytes in the file
fixedPoint[x] = expandFloat(b[2360 + (x * 4) + 0], b[2360 + (x * 4) + 1],
b[2360 + (x * 4) + 2], b[2360 + (x * 4) + 3]);
}
y = ((b[2387] & 0xff) << 24) + ((b[2386] & 0xff) << 16)
+ ((b[2385] & 0xff) << 8) + (b[2384] & 0xff); // Reassemble a milliseconds time stamp
smooth();
framX2 = graphX + 400 * (y - earlyFrame) / (lastFrame - earlyFrame);
coldY2 = graphY - int((coldestLow - fixedPoint[0]) / (coldestLow - hottestHigh) * 140.0); // Map data values into graph space
targY2 = graphY - int((coldestLow - fixedPoint[2]) / (coldestLow - hottestHigh) * 140.0);
hotY2 = graphY - int((coldestLow - fixedPoint[4]) / (coldestLow - hottestHigh) * 140.0);
if(i == 0) {
framX1 = framX2; // Set starting points for 3 graphs
coldY1 = coldY2;
targY1 = targY2;
hotY1 = hotY2;
}
stroke(128, 128, 255);
line(framX1, coldY1, framX2, coldY2); // Graph cold data point
stroke(255, 200, 64);
line(framX1, targY1, framX2, targY2); // Graph center data point
stroke(255, 128, 64);
line(framX1, hotY1, framX2, hotY2); // Graph hot data point
framX1 = framX2; // Remember endpoints of graphed lines
coldY1 = coldY2;
targY1 = targY2;
hotY1 = hotY2;
noStroke(); // Print key values onscreen for current frame
fill(BGcolor);
rect(numbersX, numbersY, 82, 152); // Erase number region
fill(BGcolor + 32); // A color to highlight any extreme values
if(y == hotLowFrame || y == hotHighFrame)
rect(numbersX, numbersY + 95, 80, 16);
if(y == targLowFrame || y == targHighFrame)
rect(numbersX, numbersY + 115, 80, 16);
if(y == coldLowFrame || y == coldHighFrame)
rect(numbersX, numbersY + 135, 80, 16);
textSize(10);
fill(255);
text(filenames[i], numbersX + 5, numbersY + 40); // Show current filename
if(celsiusFlag)
text("Frame\n\n\nElapsed sec\n\nDegrees C", numbersX + 5, numbersY + 8);
else
text("Frame\n\n\nElapsed sec\n\nDegrees F", numbersX + 5, numbersY + 8);
textSize(15);
text(i, numbersX + 5, numbersY + 25); // Print frame number
text(float(y - earlyFrame) * 0.001, numbersX, numbersY + 74); // Print elapsed time
if(celsiusFlag) { // Print temps in Celsius
fill(255, 128, 64);
text(fixedPoint[4], numbersX, numbersY + 108);
fill(255, 200, 64);
text(fixedPoint[2], numbersX, numbersY + 128);
fill(128, 128, 255);
text(fixedPoint[0], numbersX, numbersY + 148);
} else { // or print them in Farenheit
fill(255, 128, 64);
text(fixedPoint[4] * 1.8 + 32.0, numbersX, numbersY + 108);
fill(255, 200, 64);
text(fixedPoint[2] * 1.8 + 32.0, numbersX, numbersY + 128);
fill(128, 128, 255);
text(fixedPoint[0] * 1.8 + 32.0, numbersX, numbersY + 148);
}
for(x = 0; x < 768; ++x)
++histogram[b[54 + 3 * x] & 0xFF]; // Count all colors
framX2 = histogram[0];
for(x = 1; x < 256; ++x) { // Find most numerous color
if(histogram[x] > framX2) {
framX2 = histogram[x];
targY2 = x;
}
}
fill(BGcolor);
rect(histoX, histoY - 140, histoW, histoH + 1); // Erase histogram region
for(y = 0; y < 256; ++y) {
if(histogram[y] > 0) {
tempY = float(y) * (fixedPoint[3] - fixedPoint[1]) / 255.0 + fixedPoint[1]; // Convert a 8-bit value to a temperature
tempY = float(histoH) * (coldestLow - tempY) / (coldestLow - hottestHigh); // Position it on the graph Y axis
stroke(colorPal[4 * y + 2] & 0xFF, colorPal[4 * y + 1] & 0xFF, colorPal[4 * y + 0] & 0xFF); // Color map the stroke
line(histoX, histoY - int(tempY), histoX + (histoW - 1) * histogram[y] / framX2, histoY - int(tempY)); // Draw a line proportional to the pixel count
}
noStroke();
noSmooth();
textSize(10);
if(targY2 < 0x80) // Histogram peak in the dark side?
fill(255); // Set contrasting test to white
else
fill(0);
tempY = float(targY2) * (fixedPoint[3] - fixedPoint[1]) / 255.0 + fixedPoint[1]; // Convert a 8-bit value to a temperature
if(celsiusFlag) // Print the Y-positioned float value in C?
text(tempY, histoX, histoY + 3 - int(float(histoH) * (coldestLow - tempY) / (coldestLow - hottestHigh)));
else
text(tempY * 1.8 + 32.0, histoX, histoY + 3 - int(float(histoH) * (coldestLow - tempY) / (coldestLow - hottestHigh)));
}
saveFrame("mov#####.jpg"); // Save the image into a sequence for Movie Maker
}
++i;
}
}
void enlarge8bitColor() { // Convert a small gray BMP array and plot an enlarged colormapped version
int x, y;
if(lirpSmoothing) { // Bilinear interpolation?
for(y = 0; y < 23; ++y) { // Count the source pixels less one
for(x = 0; x < 31; ++x) {
for(int yLirp = 0; yLirp < 9; ++yLirp) {
int corner0 = b[54 + ((32 * y + x) + 32) * 3] & 0xFF;
int corner1 = b[54 + ((32 * y + x) + 0) * 3] & 0xFF;
int pixLeft = (corner0 * yLirp + corner1 * (8 - yLirp)) >> 3; // Lirp 1 endpoint from 2 L pixels,
int corner2 = b[54 + ((32 * y + x) + 33) * 3] & 0xFF;
int corner3 = b[54 + ((32 * y + x) + 1) * 3] & 0xFF;
int pixRight = (corner2 * yLirp + corner3 * (8 - yLirp)) >> 3; // and the other from 2 R pixels
for(int xLirp = 0; xLirp < 9; ++xLirp) {
int pixMid = (pixRight * xLirp + pixLeft * (8 - xLirp)) >> 3; // Lirp between lirped endpoints, bilinear interp
stroke(colorPal[4 * pixMid + 2] & 0xFF, colorPal[4 * pixMid + 1] & 0xFF, colorPal[4 * pixMid + 0] & 0xFF);
point(offsetX + 4 + 8 * x + xLirp, offsetY + 188 - (8 * y + yLirp)); // Draw a pixel, bottom up
}
}
}
}
for(y = 0; y < 192; ++y) { // Pad out the empty side pixels
stroke(get(offsetX + 4, offsetY + y));
line(offsetX + 0, offsetY + y, offsetX + 3, offsetY + y);
stroke(get(offsetX + 252, offsetY + y));
line(offsetX + 253, offsetY + y, offsetX + 255, offsetY + y);
}
for(x = 0; x < 256; ++x) {
stroke(get(offsetX + x, offsetY + 4));
line(offsetX + x, offsetY + 0, offsetX + x, offsetY + 3);
stroke(get(offsetX + x, offsetY + 188));
line(offsetX + x, offsetY + 189, offsetX + x, offsetY + 191);
}
} else { // Plain square pixels
noStroke();
for(y = 0; y < 24; ++y) { // Count all source pixels
for(x = 0; x < 32; ++x) {
int pixMid = b[54 + ((32 * y + x) + 0) * 3] & 0xFF;
fill(colorPal[4 * pixMid + 2] & 0xFF, colorPal[4 * pixMid + 1] & 0xFF, colorPal[4 * pixMid + 0] & 0xFF); // Get color from table
rect(offsetX + 8 * x, offsetY + 8 * (23 - y), 8, 8); // Draw a pixel, bottom up
}
}
}
if(markersVisible) { // Show the green marker crosses?
stroke(0, 192, 0); // Deep green
y = ((b[2381] & 0xff) << 8) + (b[2380] & 0xff); // Reassemble 16-bit addresses of cold / hot pixels
line(offsetX + 8 * (y & 31) + 1, offsetY + 188 - 8 * (y >> 5), offsetX + 8 * (y & 31) + 7, offsetY + 188 - 8 * (y >> 5));
line(offsetX + 8 * (y & 31) + 4, offsetY + 185 - 8 * (y >> 5), offsetX + 8 * (y & 31) + 4, offsetY + 191 - 8 * (y >> 5));
y = ((b[2383] & 0xff) << 8) + (b[2382] & 0xff);
line(offsetX + 8 * (y & 31) + 1, offsetY + 188 - 8 * (y >> 5), offsetX + 8 * (y & 31) + 7, offsetY + 188 - 8 * (y >> 5));
line(offsetX + 8 * (y & 31) + 4, offsetY + 185 - 8 * (y >> 5), offsetX + 8 * (y & 31) + 4, offsetY + 191 - 8 * (y >> 5));
y = 400;
line(offsetX + 8 * (y & 31) + 1, offsetY + 188 - 8 * (y >> 5), offsetX + 8 * (y & 31) + 7, offsetY + 188 - 8 * (y >> 5));
line(offsetX + 8 * (y & 31) + 4, offsetY + 185 - 8 * (y >> 5), offsetX + 8 * (y & 31) + 4, offsetY + 191 - 8 * (y >> 5));
}
}
void loadColorTable(int choiceNum, int offset) {
int i, x;
switch(choiceNum) {
case 1: // Load 8-bit BMP color table with computed ironbow curves
for(x = 0; x < 256; ++x) {
float fleX = (float)x / 255.0;
float fleG = 255.9 * (1.02 - (fleX - 0.72) * (fleX - 0.72) * 1.96);
fleG = (fleG > 255.0) || (fleX > 0.75) ? 255.0 : fleG; // Truncate curve
i = (int)fleG;
colorPal[offset + x * 4 + 2] = byte(i & 0xFF); // Red vals
fleG = fleX * fleX * 255.9;
i = (int)fleG;
colorPal[offset + x * 4 + 1] = byte(i & 0xFF); // Grn vals
fleG = 255.9 * (14.0 * (fleX * fleX * fleX) - 20.0 * (fleX * fleX) + 7.0 * fleX);
fleG = fleG < 0.0 ? 0.0 : fleG; // Truncate curve
i = (int)fleG;
colorPal[offset + x * 4 + 0] = byte(i & 0xFF); // Blu vals
}
break;
case 2: // Compute quadratic "firebow" palette
for(x = 0; x < 256; ++x) {
float fleX = (float)x / 255.0;
float fleG = 255.9 * (1.00 - (fleX - 1.0) * (fleX - 1.0));
i = (int)fleG;
colorPal[offset + x * 4 + 2] = byte(i & 0xFF); // Red vals
fleG = fleX < 0.25 ? 0.0 : (fleX - 0.25) * 1.3333 * 255.9;
i = (int)fleG;
colorPal[offset + x * 4 + 1] = byte(i & 0xFF); // Grn vals
fleG = fleX < 0.5 ? 0.0 : (fleX - 0.5) * (fleX - 0.5) * 1023.9;
i = (int)fleG;
colorPal[offset + x * 4 + 0] = byte(i & 0xFF); // Blu vals
}
break;
case 3: // Compute "alarm" palette
for(x = 0; x < 256; ++x) {
float fleX = (float)x / 255.0;
float fleG = 255.9 * (fleX < 0.875 ? 1.00 - (fleX * 1.1428) : 1.0);
i = (int)fleG;
colorPal[offset + x * 4 + 2] = byte(i & 0xFF); // Red vals
fleG = 255.9 * (fleX < 0.875 ? 1.00 - (fleX * 1.1428) : (fleX - 0.875) * 8.0);
i = (int)fleG;
colorPal[offset + x * 4 + 1] = byte(i & 0xFF); // Grn vals
fleG = 255.9 * (fleX < 0.875 ? 1.00 - (fleX * 1.1428) : 0.0);
i = (int)fleG;
colorPal[offset + x * 4 + 0] = byte(i & 0xFF); // Blu vals
}
break;
case 4: // Grayscale, black hot
for(x = 0; x < 256; ++x) {
colorPal[offset + x * 4 + 2] = byte(255 - x & 0xFF); // Red vals
colorPal[offset + x * 4 + 1] = byte(255 - x & 0xFF); // Grn vals
colorPal[offset + x * 4 + 0] = byte(255 - x & 0xFF); // Blu vals
}
break;
default: // Grayscale, white hot
for(x = 0; x < 256; ++x) {
colorPal[offset + x * 4 + 2] = byte(x & 0xFF); // Red vals
colorPal[offset + x * 4 + 1] = byte(x & 0xFF); // Grn vals
colorPal[offset + x * 4 + 0] = byte(x & 0xFF); // Blu vals
}
}
}
// Rebuild a float from a fixed point decimal value encoded in 4 bytes
float expandFloat(byte m1, byte m2, byte e1, byte e2) {
int fracPart;
float floatPart;
fracPart = ((e2 & 0xff) << 8) + (e1 & 0xff); // Reassemble 16-bit value
floatPart = (float)fracPart / 49152.0; // Convert into fractional portion of float
fracPart = ((m2 & 0xff) << 8) + (m1 & 0xff); // Reassemble 16-bit value
return ((float)fracPart + floatPart) - 1000.0; // Complete reconstructing original float
}
String[] listFileNames(String dir) { // Return the filenames from a directory as an array of Strings
File file = new File(dir);
if (file.isDirectory()) {
String names[] = file.list();
return names;
} else // It's not a directory
return null;
}
Almost there! Our next step is to bring in the thermal image data from the camera so we can do cool things with it.
