cah: async function (msg) {
let blackCard = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', 'blackcard.png'));
let whiteCard = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', 'whitecard.png'));
let finalImg = new Jimp(183 * (msg.white.length + 1), 254);
let blackCaption = await Jimp.read(await createCaption({
font: 'arial.ttf',
fill: '#ffffff',
text: msg.black,
size: '144x190',
gravity: 'northwest'
}));
finalImg.composite(blackCard, 0, 0);
finalImg.composite(blackCaption, 19, 19);
for (let i = 0; i < msg.white.length; i++) {
let whiteCaption = await Jimp.read(await createCaption({
font: 'arial.ttf',
fill: 'black',
text: msg.white[i],
size: '144x190',
gravity: 'northwest'
}));
finalImg.composite(whiteCard, 183 * (i + 1), 0);
finalImg.composite(whiteCaption, 183 * (i + 1) + 19, 19);
}
finalImg.getBuffer(Jimp.MIME_PNG, (err, buffer) => {
submitBuffer(msg.code, buffer);
});
},
export async function comparePngs(sessionPath, baselinePath, diffPath, sessionDirectory, log) {
log.debug(`comparePngs: ${sessionPath} vs ${baselinePath}`);
const session = (await Jimp.read(sessionPath)).clone();
const baseline = (await Jimp.read(baselinePath)).clone();
if (session.bitmap.width !== baseline.bitmap.width || session.bitmap.height !== baseline.bitmap.height) {
console.log('expected height ' + baseline.bitmap.height + ' and width ' + baseline.bitmap.width);
console.log('actual height ' + session.bitmap.height + ' and width ' + session.bitmap.width);
const width = Math.min(session.bitmap.width, baseline.bitmap.width);
const height = Math.min(session.bitmap.height, baseline.bitmap.height);
session.resize(width, height);//, Jimp.HORIZONTAL_ALIGN_LEFT | Jimp.VERTICAL_ALIGN_TOP);
baseline.resize(width, height);//, Jimp.HORIZONTAL_ALIGN_LEFT | Jimp.VERTICAL_ALIGN_TOP);
}
session.quality(60);
baseline.quality(60);
log.debug(`calculating diff pixels...`);
// Note that this threshold value only affects color comparison from pixel to pixel. It won't have
// any affect when comparing neighboring pixels - so slight shifts, font variations, or "blurry-ness"
// will still show up as diffs, but upping this will not help that. Instead we keep the threshold low, and expect
// some the diffCount to be lower than our own threshold value.
const THRESHOLD = .1;
const { image, percent } = Jimp.diff(session, baseline, THRESHOLD);
log.debug(`percentSimilar: ${percent}`);
if (percent > 0) {
image.write(diffPath);
// For debugging purposes it'll help to see the resized images and how they compare.
session.write(path.join(sessionDirectory, `${path.parse(sessionPath).name}-session-resized.png`));
baseline.write(path.join(sessionDirectory, `${path.parse(baselinePath).name}-baseline-resized.png`));
}
return percent;
}
upload(req, res, function (err) {
if (err) {
if (err.code == "LIMIT_FILE_SIZE") {
req.flash('uploadMessage', 'File too large, choose another plz!');
res.redirect('/photo');
}
return res.end("Error loading file.");
}
var imgName2 = '1' + imgName;
var imgName3 = '2' + imgName;
jimp.read(path.normalize("./public/photo/" + imgName), function (err, imgName) {
if (err) throw err;
imgName.scaleToFit(400, 600) // resize
.quality(60) // set JPEG quality
.write("./public/photo/" + imgName2); // save
});
jimp.read(path.normalize("./public/photo/" + imgName), function (err, imgName) {
if (err) throw err;
imgName.scaleToFit(200, 300) // resize
.quality(60) // set JPEG quality
.write("./public/photo/" + imgName3); // save
});
res.status(200).send(JSON.stringify({ i128: imgName }));
console.log(req);
});
starvstheforcesof: async function (msg) {
let avatar = await Jimp.read(await getResource(msg.avatar));
avatar.resize(700, 700);
let color = colorThief.getColor(avatar);
//color = color.map(a => a / 2);
let lowest = Math.min(color[0], color[1], color[2]);
color = color.map(a => Math.min(a - lowest, 32));
console.debug(color);
let bgImg = im(await getBufferFromJimp(avatar));
bgImg.command('convert');
bgImg.out('-matte').out('-virtual-pixel').out('transparent');
bgImg.out('-extent');
bgImg.out('1468x1656');
bgImg.out('-distort');
bgImg.out('Perspective');
bgImg.out("0,0,0,208 700,0,1468,0 0,700,0,1326 700,700,1468,1656");
let jBgImg = await Jimp.read(await getBufferFromIM(bgImg));
jBgImg.resize(734, 828);
let foreground = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', `starvstheforcesof.png`));
foreground.resize(960, 540);
let actions = [];
if (color[0] > 0) actions.push({ apply: 'red', params: [color[0]] });
if (color[1] > 0) actions.push({ apply: 'green', params: [color[1]] });
if (color[2] > 0) actions.push({ apply: 'blue', params: [color[2]] });
foreground.color(actions);
let img = new Jimp(960, 540);
jBgImg.crop(0, 104, 600, 540);
img.composite(jBgImg, 430, 0);
img.composite(foreground, 0, 0);
img.getBuffer(Jimp.MIME_PNG, (err, buffer) => {
submitBuffer(msg.code, buffer);
});
},
retarded: async function (msg) {
let buf = await createCaption({
font: 'ARCENA.ttf',
fill: 'black',
stroke: 'white',
strokewidth: 5,
text: msg.text,
size: '272x60'
});
let text = await Jimp.read(buf);
let img = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', `retarded.png`));
if (msg.avatar) {
let avatar = await Jimp.read(await getResource(msg.avatar));
let smallAvatar = avatar.clone();
smallAvatar.resize(74, 74);
img.composite(smallAvatar, 166, 131);
avatar.resize(171, 171);
avatar.rotate(18);
img.composite(avatar, 277, 32);
}
img.composite(text, 268, 0);
img.getBuffer(Jimp.MIME_PNG, (err, buffer) => {
submitBuffer(msg.code, buffer);
});
},
.then(function() {
expect(jimpImage001.bitmap.width).toEqual(10);
expect(jimpImage001.bitmap.height).toEqual(10);
expect(jimpImage002.bitmap.width).toEqual(8);
expect(jimpImage002.bitmap.height).toEqual(8);
expect(pipelineExtras0001.source.equals(imageBuffer)).not.toBe(true);
expect(pipelineExtras0002.source.equals(imageBuffer)).not.toBe(true);
// expect the buffers to still be readable by jimp (valid image buffer)
var promises = [];
promises.push(Jimp.read(pipelineExtras0001.source)
.then(function(image) {
expect(image.bitmap.height).toEqual(10);
expect(jimpImage001.bitmap.height).toEqual(10);
}));
promises.push(Jimp.read(pipelineExtras0002.source)
.then(function(image) {
expect(image.bitmap.height).toEqual(8);
expect(jimpImage002.bitmap.height).toEqual(8);
}));
Promise.all(promises)
.then(function() {
done();
});
});
delete: async function (msg) {
let buf = await createCaption({
text: msg.input,
font: 'whitneybold.ttf',
size: '512x24',
gravity: 'South',
fill: '#f8f8f8'
});
let originalText = await Jimp.read(buf);
let text = new Jimp(originalText.bitmap.width, originalText.bitmap.height + 8);
text.composite(originalText, 0, 4);
text.autocrop();
let iterations = Math.ceil(text.bitmap.width / 64);
console.debug(text.bitmap.width);
let delete1 = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', 'delete1.png'));
let delete2 = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', 'delete2.png'));
let delete3 = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', 'delete3.png'));
let cursor = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', 'cursor.png'));
let width = 128 + (iterations * 64);
let workspace = new Jimp(width, 84);
workspace.composite(delete1, 0, 0);
workspace.composite(delete3, width - 64, 0);
for (let i = 0; i < iterations; i++) {
workspace.composite(delete2, (i + 1) * 64, 0);
}
workspace.composite(text, 64 + ((iterations * 64 - text.bitmap.width + 32) / 2), 14 + ((48 - text.bitmap.height) / 2));
workspace.composite(cursor, 64 + ((iterations * 64 - cursor.bitmap.width + 32) / 2), 48);
//let img = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', `SHIT${msg.plural ? 'S' : ''}.png`));
//img.composite(text, 810, 31);
workspace.getBuffer(Jimp.MIME_PNG, (err, buffer) => {
submitBuffer(msg.code, buffer);
});
},
triggered: async function (msg) {
let frameCount = 8;
let frames = [];
let avatar = await Jimp.read(await getResource(msg.avatar));
avatar.resize(320, 320);
if (msg.inverted) avatar.invert();
if (msg.horizontal) avatar.flip(true, false);
if (msg.vertical) avatar.flip(false, true);
if (msg.sepia) avatar.sepia();
if (msg.blur) avatar.blur(10);
if (msg.greyscale) avatar.greyscale();
let triggered = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', `triggered.png`));
triggered.resize(280, 60);
triggered.opacity(0.8);
let overlay = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', `red.png`));
let buffers = [];
let encoder = new GIFEncoder(256, 256);
let stream = encoder.createReadStream();
stream.on('data', function (buffer) {
buffers.push(buffer);
});
stream.on('end', function () {
let buffer = Buffer.concat(buffers);
submitBuffer(msg.code, buffer);
});
let base = new Jimp(256, 256);
let temp, x, y;
for (let i = 0; i < frameCount; i++) {
temp = base.clone();
if (i == 0) {
x = -16;
y = -16;
} else {
x = -32 + (getRandomInt(-16, 16));
y = -32 + (getRandomInt(-16, 16));
}
temp.composite(avatar, x, y);
if (i == 0) {
x = -10;
y = 200;
} else {
x = -12 + (getRandomInt(-8, 8));
y = 200 + (getRandomInt(-0, 12));
}
temp.composite(overlay, 0, 0);
temp.composite(triggered, x, y);
frames.push(temp.bitmap.data);
}
encoder.start();
encoder.setRepeat(0);
encoder.setDelay(20);
for (let frame of frames) encoder.addFrame(frame);
encoder.finish();
},
free: async function (msg) {
let topCaption = await Jimp.read(await createCaption({
text: msg.top,
font: 'impact.ttf',
fill: 'white',
stroke: 'black',
strokewidth: 5,
gravity: 'north',
size: '380x100'
}));
let bottomText = msg.bottom || 'CLICK HERE TO\nFIND OUT HOW';
let bottomCaption = await Jimp.read(await createCaption({
text: bottomText,
font: 'arial.ttf',
fill: 'white',
gravity: 'center',
size: '380x70'
}));
let back1 = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', 'freefreefree0.png'));
let back2 = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', 'freefreefree1.png'));
let frameCount = 6;
let frames = [];
let buffers = [];
let encoder = new GIFEncoder(400, 300);
let stream = encoder.createReadStream();
stream.on('data', function (buffer) {
buffers.push(buffer);
});
stream.on('end', function () {
submitBuffer(msg.code, Buffer.concat(buffers));
});
let base = new Jimp(400, 300);
for (let i = 0; i < frameCount; i++) {
let temp = base.clone();
temp.composite(i < frameCount / 2 ? back1 : back2, 0, 0);
temp.composite(topCaption, i == 0 ? 10 : getRandomInt(-25, 25), i == 0 ? 15 : getRandomInt(0, 20));
temp.composite(bottomCaption, 10, 228);
frames.push(temp.bitmap.data);
}
encoder.start();
encoder.setRepeat(0);
encoder.setDelay(50);
for (let frame of frames) encoder.addFrame(frame);
encoder.finish();
},
art: async function (msg) {
let avatar = await Jimp.read(await getResource(msg.avatar));
avatar.resize(370, 370);
let foreground = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', `art.png`));
let img = new Jimp(1364, 1534);
img.composite(avatar, 903, 92);
img.composite(avatar, 903, 860);
img.composite(foreground, 0, 0);
img.getBuffer(Jimp.MIME_PNG, (err, buffer) => {
submitBuffer(msg.code, buffer);
});
},
truth: async function (msg) {
let buf = await createCaption({
text: msg.text,
font: 'AnnieUseYourTelescope.ttf',
size: '96x114',
gravity: 'North'
});
let text = await Jimp.read(buf);
let img = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', `truth.png`));
img.composite(text, 95, 289);
img.getBuffer(Jimp.MIME_PNG, (err, buffer) => {
submitBuffer(msg.code, buffer);
});
},
clippy: async function (msg) {
let buf = await createCaption({
text: msg.text,
font: 'arial.ttf',
size: '290x130',
gravity: 'North'
});
let text = await Jimp.read(buf);
let img = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', `clippy.png`));
img.composite(text, 28, 36);
img.getBuffer(Jimp.MIME_PNG, (err, buffer) => {
submitBuffer(msg.code, buffer);
});
},
module.exports = function (source, map) {
this.cacheable();
var callback = this.async();
var originalImage = path.resolve(this.resource)
this.addDependency(originalImage);
var config = {
publicPath: false,
name: "[name]_original.[ext]"
};
Jimp.read(originalImage).then(function (image) {
var extension = loaderUtils.interpolateName(this, '.[ext]', {});
var size = {
width: image.bitmap.width,
height: image.bitmap.height
};
image.scaleToFit(42, 42) // resize
.quality(60) // set JPEG quality
image.getBuffer(Jimp.MIME_JPEG, function (err, result) {
var dataUri = new Datauri().format(extension, result).content;
callback(null, "module.exports = " + JSON.stringify({
dataUri: dataUri,
size: size
}) + ";", map);
}.bind(this));
}.bind(this)).catch(function (err) {
console.log(err);
});
}
shit: async function (msg) {
let buf = await createCaption({
text: msg.text,
font: 'animeace.ttf',
size: '200x160',
gravity: 'South'
});
let text = await Jimp.read(buf);
let img = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', `SHIT${msg.plural ? 'S' : ''}.png`));
img.composite(text, 810, 31);
img.getBuffer(Jimp.MIME_PNG, (err, buffer) => {
submitBuffer(msg.code, buffer);
});
},
function square(src, dest, sizes, cb) {
if (!src) {
throw new Error('Source image should be provided');
}
if (is.number(dest) || is.array(dest) || is.object(dest)) {
sizes = dest;
dest = path.resolve(process.cwd(), path.dirname(src));
}
jimp.read(src, function (err, image) {
let tasks = prepareSquareTask(src, sizes);
if (err) {
cb(err);
return;
}
eachAsync(Object.keys(tasks), (size, index, done) => {
size = Math.floor(size);
image.clone()
.resize(size, size)
.quality(100)
.write(path.join(dest, tasks[size].src), done);
}, () => {
cb(null, tasks);
});
});
}
router.all('/app/settings/rotate', function(req, res){
var angle = parseInt(req.query.angle); // Gets the given angle
var url = req.query.url // Gets the given URL
if(angle == "undefined" || angle == "" || typeof(angle) != "number"){
angle = 0; // Sets angle to 0 if its not set to a number
}
angle = Math.round(angle/90)*90; // Rounds the angle to the neerest 90 degrees
jimp.read(url, function(err, image){ // Gets the image file from the URL
if (err){
utils.handleError(err, res);
}else{
image.rotate(angle); // Rotates the image *clockwise!*
//image.resize( width, jimp.AUTO);
image.getBuffer(jimp.MIME_PNG, function(err2, image2){ // Buffers the image so it sends correctly
if(err2){
utils.handleError(err2, res);
}else{
res.setHeader('Content-type', 'image/png'); // Makes sure its a png
res.send(image2); // Sends the image to the browser.
}
});
}
});
});
.then(function(image) {
return Image.read(image).then(function(img) {
self.oriWidth = img.bitmap.width;
self.oriHeight = img.bitmap.height;
self._resize();
});
});
thesearch: async function (msg) {
let buf = await createCaption({
text: msg.text,
fill: '#393b3e',
font: 'SFToontime.ttf',
size: '160x68'
});
let text = await Jimp.read(buf);
let img = await Jimp.read(path.join(__dirname, '..', '..', 'res', 'img', `thesearch.png`));
img.composite(text, 60, 331);
img.getBuffer(Jimp.MIME_PNG, (err, buffer) => {
submitBuffer(msg.code, buffer);
});
},
function Glitchin( file, opts ){
_.each(opts, function( value, key ){
options[key] = value;
});
return Jimp.read(file).then(function( image ){
try {
var ext = file.substr(-4, 4);
var mime;
if( ext === '.jpg' || ext === 'jpeg' ){
mime = Jimp.MIME_JPEG;
} else if( ext === '.png' ){
mime = Jimp.MIME_PNG;
} else if( ext === '.bmp' ){
mime = Jimp.MIME_BMP;
}
} catch( e ){
mime = options.mime;
} finally {
image.bitmap.mime = mime;
}
return processBuffer(image);
}).catch(error);
}
return new Promise(function(resolve, reject) {
var currentColor = 0;
var colorCounter = 0;
Jimp.read("./gui/png/"+img).then(function (image) {
var fbuf = new Buffer(0);
image.dither565();
for (var x=0;x<image.bitmap.width;x++) {
for (var y=0;y<image.bitmap.height;y++) {
var b = image.getPixelColor(x,y);
if (x == 0 && y == 0) {
currentColor = b;
colorCounter += 1;
} else {
if (b == currentColor) {
colorCounter += 1;
} else {
// write previous color
var rgba = Jimp.intToRGBA(currentColor);
var _p = rgba.r << 8 | rgba.g << 3 | rgba.b >> 3;
var buf = new Buffer(3);
buf.writeUInt8(colorCounter);
buf.writeUInt16LE(_p, 1);
fbuf = Buffer.concat([fbuf, buf]);
currentColor = b;
colorCounter = 1;
}
}
}
}
console.info("RESOLVING ", fbuf.length)
resolve(fbuf);
});
});
router.post('/resize', upload_local.fields([ { name: 'file' } ]), function(req, res) {
console.log('files', req.files);
//console.log('files.file[0]', req.files.file[0]);
//console.log('body', req.body);
const payload = {
title : 'Resize | Jimp',
data: {}
};
Jimp.read(req.files.file[0].path).then(image => {
return image.resize(64, 64).getBase64Async(Jimp.MIME_PNG); // resize
}).then(function(base64) {
payload.data.image_src = base64;
res.render('jimp/resize', payload);
}).catch(function(err) {
console.error(err);
payload.data.err = err;
res.render('jimp/resize', payload);
});
// res.render('jimp/resize', payload);
});
fs.readdirSync('./png').forEach(function(file) {
var _e = file.split(".");
if (_e[1] == 'png') {
var c = 0;
var img = _e[0];
Jimp.read("./png/"+img+'.png').then(function (image) {
image.dither565();
var buf = new Buffer((image.bitmap.width * image.bitmap.height)*2);
var str = "";
for (var x=0;x<image.bitmap.width;x++) {
for (var y=0;y<image.bitmap.height;y++) {
var b = image.getPixelColor(x,y);
var rgba = Jimp.intToRGBA(b);
var _p = rgba.r << 8 | rgba.g << 3 | rgba.b >> 3;
if (x>0 || y>0) str += ",";
str += _p;
buf.writeUInt16LE(_p, c, 2);
c+=2;
}
}
fs.writeFile('./raw/'+img+'.dat', buf);
fs.writeFile('./str/'+img+'.txt', str);
}).catch(function (err) {
console.error(err);
});
}
});
objectStream.on('end', async function () {
encoder.firstFrame = false;
let output = '';
let i = 0;
for (let char of msg.message) {
if (i <= 200) {
output += char;
console.debug(i, output);
let img = im(767, 572, '#ffffff').command('convert');
img.font(path.join(__dirname, '..', '..', 'res', 'img', 'fonts', 'Ace-Attorney.ttf'), 24);
img.out('-fill').out('#000000');
img.out('-gravity').out('northwest');
img.out('-geometry').out('+50+50');
img.out(`caption:${output}`);
frames.push(await getBufferFromIM(img));
i++;
}
}
encoder.start();
encoder.setRepeat(-1);
encoder.setDelay(30);
for (let frame of frames) {
let temp = await Jimp.read(frame);
encoder.addFrame(temp.bitmap.data);
}
encoder.finish();
});
fs.readFile(images + request.params.id + '.' + config.extension, function(error, data) { // open and read the file
if(error) { // if there's an error
return next(error) // pass the error to the error handling middleware
}
response.set({ // set the response headers
'Content-Type': 'image/' + config.extension, // set the Content-Type header
'Content-Length': data.length // set the Content-Length header
})
if(request.query.width) { // if width is provided, resize
if(!request.query.height) { // if there's not height provided
request.query.height = jimp.AUTO //set the height to auto
}
jimp.read(data, function(error, image) { // read the image data
if(error) { // if there's an error
return next(error) // pass the error to the error handling middleware
}
image.contain(Number(request.query.width), Number(request.query.height), function(error, image) { // resize the image
if(error) { // if there's an error
return next(error) // pass the error to the error handling middleware
}
image.getBuffer('image/' + config.extension, function(error, image) { // get the image buffer
if(error) { // if there's an error
return next(error) // pass the error to the error handling middleware
}
return response.send(image) // return the image buffer as the response
})
})
})
} else {
return response.send(data) // return the image as the response
}
})
function processImage(src, o) {
var options = o || {};
var imgPath = src;
var imgExt = path.extname(imgPath);
var imgName = path.basename(imgPath, imgExt);
var modifiers = {
width: options.width ? options.width : -1,
height: options.height ? options.height : -1,
fit: options.fit ? options.fit : 'contain'
}
var modifiersString = `-${modifiers.width == -1 ? "0" : modifiers.width}x${modifiers.height == -1 ? "0" : modifiers.height}_${modifiers.fit}`;
var modifiedName = imgName + (o ? modifiersString : "") + imgExt;
if (fileExists(`${projectPath}/build/assets/img/${modifiedName}`)) return '/assets/img/' + modifiedName;
jimp.read(src, function(err, img) {
if (err) return console.log(err.stack);
if (o) {
if (modifiers.fit == "contain") img.contain(modifiers.width, modifiers.height);
if (modifiers.fit == "cover") img.cover(modifiers.width, modifiers.height);
if (modifiers.fit == "resize") img.resize(modifiers.width, modifiers.height);
}
img.write(`${projectPath}/build/assets/img/${modifiedName}`);
});
return '/assets/img/' + modifiedName;
}
db.users.getProfile(req.user.name, function(err, profile) {
if (err) {
res.json({
message: "Failed to fetch profile information."
}, 500);
}
Jimp.read(req.file.path)
.then(function(image) {
image
.quality(Config.get("profiles.header.quality"))
.cover(Config.get("profiles.header.width"), Config.get("profiles.header.height"));
image.getBuffer(Config.get("profiles.header.mime"), function(err, buff) {
if (err) throw err;
var filename = "profiles/headers/" + req.user.name + "-" + Date.now() + ".jpg";
var bucket = new AWS.S3({params: {Bucket: Config.get("uploads.s3_bucket")}});
var params = {
Key: filename,
Body: buff,
ContentType: req.file.mimetype,
ACL: 'public-read'
};
bucket.upload(params, function(err) {
if (err) throw err;
var src = Config.get("uploads.uploads_url") + filename;
Redis.createClient(Config.get("redis.databases").uploads, function(err, client) {
if (err) {
return res.json({
message: "Failed to upload image."
}, 500);
}
var key = "uploads:headers:" + req.user.name;
client.hset(key, src, Date.now(), function(err) {
if (err) {
return res.json({
message: "Failed to upload image."
}, 500);
}
client.quit();
fs.unlink(req.file.path);
res.json({
src: src
});
});
});
});
});
})
.catch(function(err) {
console.log(err);
res.json({
message: "Failed to upload image."
}, 500);
});
});
function imageToConsole (photoPath, cols, callback) {
Jimp.read(photoPath, (error, image) => {
if (error) {
return callback(error)
}
const cursor = ansi(process.stdout)
const resizedImage = image.resize(cols, Jimp.AUTO)
const height = resizedImage.bitmap.height
const width = resizedImage.bitmap.width
for (let y = 0; y < height; y++) {
for (let x = 0; x < width; x++) {
let hexColor = `${resizedImage.getPixelColor(x, y).toString(16).substr(0, 6)}`
if (hexColor.length !== 6) {
hexColor = '000000'
}
cursor
.hex(`#${hexColor}`)
.write('██')
.reset()
}
cursor.write('\n')
}
callback(null, true)
})
}
sessionStore.load(sid, function(err, session) {
if (!session || !session.passport.user || err) {
return 'no passport';
}
var emails = session.passport.user.emails;
user.email = emails[0].value;
user.name = session.passport.user.displayName;
user.provider = session.passport.user.provider;
user.image = session.passport.user._json.picture;
Jimp.read(user.image, function(err, image1){ // Gets the image file from the URL
if (!err){
Jimp.read(__dirname + "/../../html/img/google_default.jpg", function(err, image2){ // Gets the image file from the img folder
if (!err){
if(Jimp.distance(image1, image2) === 0){
user.image = "https://s.gravatar.com/avatar/" + crypto.createHash('md5').update(user.email).digest('hex') + "?d=identicon";
var roomId = socket.room;
var person;
client.get(roomId, function(err, obj) {
if(!obj){
return false;
}
var room = JSON.parse(obj);
for(person in room.people){
var this_person = room.people[person];
if(this_person.email == user.email){
this_person.image = user.image;
}
}
client.set(roomId, JSON.stringify(room), function(err){
if(!err){
io.sockets.in(socket.room).emit('members.update', {
"roomId": socket.room,
"people": room.people
});
}
});
});
}
}
});
}
});
client.lrange("people", 0, -1, function(err, obj) {
if(!obj){
return false;
}
for(var person in obj){
var this_person = JSON.parse(obj[person]);
if(this_person.email == user.email && this_person.id == sid){
return false;
}
}
client.rpush(["people", JSON.stringify({"email": user.email, "id": socket.id})], function(err) {});
});
console.log(user.email +' connected: '+sid);
});
function greyOut(fname, callback){
jimp.read(fname+'.jpg', function(readErr, rawImg){
if(readErr) return readErr;
rawImg.grayscale().write(fname+'-bw.jpg');
callback();
});
}
Jimp.read(user.image, function(err, image1){ // Gets the image file from the URL
if (!err){
Jimp.read(__dirname + "/../../html/img/google_default.jpg", function(err, image2){ // Gets the image file from the img folder
if (!err){
if(Jimp.distance(image1, image2) === 0){
user.image = "https://s.gravatar.com/avatar/" + crypto.createHash('md5').update(user.email).digest('hex') + "?d=identicon";
var roomId = socket.room;
var person;
client.get(roomId, function(err, obj) {
if(!obj){
return false;
}
var room = JSON.parse(obj);
for(person in room.people){
var this_person = room.people[person];
if(this_person.email == user.email){
this_person.image = user.image;
}
}
client.set(roomId, JSON.stringify(room), function(err){
if(!err){
io.sockets.in(socket.room).emit('members.update', {
"roomId": socket.room,
"people": room.people
});
}
});
});
}
}
});
}
});