A foreign programmer is really good at playing. He used this technology to trick everyone in the company...

[51CTO.com Quick Translation] I like to use Photoshop to modify various things and then publish the results within the Slack company. I enjoy it because it brings new ideas every time.

But it is really tedious to repeatedly open Photoshop and copy/paste the facial image.

[[185213]]

When I first came up with the idea, I realized that this project would have three main components:

1. Simple image modification

2. Slack Integration

3. Face Detection

I had used the image and image/draw packages in Go before and read a few articles about them, so I felt confident that I could accomplish this task. That was it for component 1.

I've also built a toy Slack bot in Go using a few commands I found on Google. The lack of an official Go Slack client makes things more complicated, but for basic purposes I'm confident I can get the job done by downloading and uploading images through Slack. Component 2 is not a problem.

The only thing I wasn't sure about was how easy it would be to do face detection. I googled golang face detection and the first result I clicked on led to a question on StackOverflow about the go-opencv computer vision library. After looking through the face detection sample project in that library, I knew everything I needed to know. Component 3 was also solved.

Face Detection

Since I was most familiar with it, I decided to start with face detection. This was the most difficult part of the project, so I wanted to see if I could do it first, otherwise all the other work would be meaningless.

I decided to wrap the go-opencv library as much as possible. To be sure, the opencv data types are different from the Go standard library, at least in terms of the two interfaces defined for Image and Rectangle, so some adjustments had to be made.

I found a reference to the opencv.FromImage method, which is responsible for converting Go's image.Image to the opencv library format. This means that I no longer need to pass the file path to the opencv.LoadImage method to convert it, but can directly deal with the image stored in memory. This saves the step of saving the image in the file system after receiving it from Slack.

Unfortunately, I can’t load the Haar facial recognition XML file using the same conversion method, but the results are acceptable to me, so I’ll leave it like this for now.

Based on this, I wrote the following facefinder package:

 package facefinder import ( "image""github.com/lazywei/go-opencv/opencv" ) var faceCascade *opencv.HaarCascade type Finder struct { cascade *opencv.HaarCascade } func NewFinder(xml string) *Finder { return &Finder{ cascade: opencv.LoadHaarClassifierCascade(xml), } } func (f *Finder) Detect(i image.Image) []image.Rectangle { var output []image.Rectangle faces : = f .cascade.DetectObjects(opencv.FromImage(i)) for _, face : = range faces { output = append (output, image.Rectangle{ image.Point{face.X(), face.Y()}, image.Point{face.X() + face.Width(), face.Y() + face.Height()}, }) } return output }

Then, I can easily find the faces in the image:

 imageReader, _ : = os .Open(imageFile) baseImage, _, _ : = image .Decode(imageReader) finder : = facefinder .NewFinder(haarCascadeFilepath) faces : = finder .Detect(baseImage) for _, face : = range faces { // [...] }

I copied a few snippets of "draw rectangle" code from Google to do a functional check and confirmed that the above code was indeed working. With the position information, I also tinkered with an image loading conversion function (which was more concerned with errors than rushing to cram everything in).

 func loadImage(file string) image.Image { reader, err : = os .Open(file) if err != nil { log.Fatalf("error loading %s: %s", file, err) } img, _, err : = image .Decode(reader) if err != nil { log.Fatalf("error loading %s: %s", file, err) } return img }

Image Modification

Next, my new loop looks like this:

 baseImage : = loadImage (imageFile) chrisFace : = loadImage (chrisFaceFile) bounds : = baseImage .Bounds() finder : = facefinder .NewFinder(haarCascadeFilepath) faces : = finder .Detect(baseImage) // Convert image.Image to a mutable image.ImageRGBA canvas : = image .NewRGBA(bounds) draw.Draw(canvas, bounds, baseImage, bounds.Min, draw.Src) for _, face : = range faces { draw.Draw( canvas, face, chrisFace, bounds.Min, draw.Src, ) }

It's exciting that the test results went well.

[[185214]]

Anyway, the actual effect is far beyond my expectations. The rectangle drawing algorithm is awesome!

In terms of image modification, I first had to figure out how to get rid of the black background. I had used the PNG method with a transparent background before, so I knew it would work. After some googling, I stumbled upon draw.Over in the draw.Draw function. I tucked it into the draw.Src I was using, and it worked!

[[185215]]

Although I could use a feather pen to slowly draw the edges, a voice in my head told me that this was almost enough.

OK, now I need to scale the face down a bit. Sure enough, if I put the face into a rectangle of the exact same size, it won't fit. This is just a face detector, not a head detector, which means the rectangle I get back isn't suitable for replacing an entire head. I wrote a quick function to add a certain amount of margin to the image.Rectangle, which I ended up setting to 30%.

Once that was done, I started resizing/matching the images. I ended up choosing disintegration/imaging, which had a simple imaging.Fit function and offered other transformations like horizontal mirroring. I didn't have many source images of faces, so I thought the mirroring feature would provide another image option.

After importing, my new loop looks like this:

 for _, face : = range faces { // Pad the rectangle by 30 percent rect : = rectMargin (30.0, face) // Grab a random face (also 50/50 chance it's mirrored) newFace : = chrisFaces .Random() chrisFace : = imaging .Fit(newFace, rect.Dx(), rect.Dy(), imaging.Lanczos) draw.Draw( canvas, rect, chrisFace, bounds.Min, draw.Over, ) }

I ran a new round of tests and the results were pretty good!

[[185216]]

[[185217]]

At this point, I realized I had created something truly valuable.

Slack Integration

I converted the face modification code into a runnable binary file, and planned to package it into a Slack bot. The reason for converting it to binary form first is to make it easier to test and package it after confirming that everything is correct. Now the time is right, I will turn it into a Slack bot.

Of course, due to my own limitations, I turned to Google.

The first result is what I need. I spent a lot of time reading Slack’s API documentation and practicing it, and finally I got the following results:

good

The first iteration used Slack uploads, but being a free Slack layer meant that was less than ideal. I instead stored the output locally on my own server and then linked it to Slack. Since Slack automatically expands most image links, this doesn’t affect the user experience for most people, and it won’t attract the attention of your boss.

With easier access, I was now able to quickly get a lot of experimental faces. I realized that if it couldn't find any faces, it would just revert to the same old images all the time - which wasn't fun. So I adjusted the loop to:

 iflen(faces) == 0 { // Grab a specific face and resize it to 1/3 the width// of the base image face : = imaging .Resize( chrisFaces[0], bounds.Dx()/3, 0, imaging.Lanczos, ) face_bounds : = face .Bounds() draw.Draw( canvas, bounds, face, // I'll be honest, I was a couple beers in when I came up with this and I// have no idea how it works exactly, but it puts the face at the bottom of// the image, centered horizontally with the lower half of the face cut off bounds.Min.Add(image.Pt( -bounds.Max/2+face_bounds.Max.X/2, -bounds.Max.Y+int(float64(face_bounds.Max.Y)/1.9), )), draw.Over, ) }

The result is now:

[[185218]]

I am personally very satisfied with this solution.

At this point, all the work was ready, and I just had to wait for my colleagues’ reactions. I completed the entire process from concept to prototype in just one night, and no one knew what kind of surprise I had prepared for them.

As of now, my manager is the most active user of Chrisbot manual configuration.

Sorry Mat, it looks like automation will eventually replace human jobs.

[[185219]]

But the guy himself was very happy.

Before long, the entire office was sending pictures to @Chrisbot.

I was pleasantly surprised to find that it actually handled overlapping faces correctly, drawing the farthest faces first. While this is purely a side effect of the actual order in which the rectangles are returned by the go-opencv library, I was very happy with the result.

However, although automated facial replacement has greatly increased the number of Chris' appearances in Slack, some people still believe that the results of manual operation are more spiritual.

It has to be admitted that their point of view does have some validity - at least in some cases.

[Translated by 51CTO. Please indicate the original translator and source as 51CTO.com when reprinting on partner sites]