Wednesday, May 6, 2015

TECHNOLOGY | Gaussian + Laplacian, standard deviation high-pass filters = decloaked tissue-eroding entities

A band-pass filter prototype that processes digital media using two, successive low-pass image-processing filters (comprised of Gaussian and Laplacian transforms) revealed a lot more from a video made during an attack than any other video showing such activity—that is, by the way, demonic entities eating my face [see DRAFT | TECHNOLOGY | Demonic maggots erode face, neck (iPhone Photo Editing Extension); see also PICS | Torture by sucker demon].

Although a procedure to decloak and enhance sucker-demon attacks was posted to this blog just a few months ago [see TECHNOLOGY | Finding sucker demon-attacks in digital media], this newer, experimental version uses the same filters common to medical imaging devices that perform surface analysis, yielding far better results.

The same applies to a second, in-development imaging filter, particularly, one based on pixel variance and standard deviation statistics. Following are sample still frames from a video made this afternoon using that filter, captioned with points of interest:

Left temple, top of head, right cheek (various entities)Right shoulder, left cheek (various entities)
Left temple, top of head, right cheek (various entities)Eye sockets, chin, jaw bone, nose
Left eye socket (protuding white spikes)Left jawbone (either entity or device)
Of particular note is the still frame showing either an entity or a device. The body suggests the former (it looks like a lady bug); the perfectly straight legs, the latter (they look like prongs):

If this is a device of some kind, the image is the second of its kind showing one
Something similar can be seen in another image, which is posted SOFTWARE | Chroma-focusing and chroma-mapping Photo Booth effects released, and which I then postulated was an electronics piece of some kind:
I identified a similar looking object shown in an older image as electronics, even though, in the video, it walked up my face; most likely, because of its metal-colored/textured outer shell
Post-processing a video made tonight using a dual-combination of high-pass filters, specifically, Gaussian and Laplacian, yielded great results, too. The following is a screen recording showing the effects of various parameter settings as the video plays:

Here's the RMS filter kernel code (OpenGL ES 3.0) I used:

A Core Image kernel routine that computes a Laplacian effect.
The code looks up the source pixel in the sampler and then subtracts a new pixel based on a Laplace transform.

kernel vec4 coreImageKernel(sampler image, sampler median, float poles)
vec4 pixel = unpremultiply(sample(image, samplerCoord(image)));
vec4 mixel = unpremultiply(sample(median, samplerCoord(median)));
pixel.rgb = sqrt(vec3(1.0) / vec3(1.0) * pow(pixel.rgb, vec3(2.0 * poles)));
pixel.rgb -= mixel.rgb;
return premultiply(pixel);

Here is the image-processing pipeline in Quartz Composer:

The image-processing pipeline, inside a macro with a single image input and output and published inputs for the Gaussian blur radius amount and the Laplacian poles quantity (right: radius and pole adjustment controls)
Here's the variance/standard deviation filter kernel code used in a customized iPhone camera app that I use to test Core Image filters:

The Core Image Filter version will have the following sliders:
Divisor [-1 to 1, default 0]: Subtract or add to the mean divisor for enhanced detail
Mix [0 to 1, default 0]: Mix between standard deviation with original pixel values

The filter will come in different sizes: 3 x 3, 5 x 5, 7 x 7, and 9 x 9

kernel vec4 coreImageKernel(sampler u, float divisor, float amount)
    vec4 pixel = unpremultiply(sample(u, samplerCoord(u)));
    vec2 xy = destCoord();
    vec4 mean  = vec4(0.0);
    vec4 mean2 = vec4(0.0);
    for (int i = -3; i <= 3; i++)
        for (int j = -3; j <= 3; j++ )
            mean  += sample(u, samplerTransform(u, xy+vec2(i, j)));
            mean2 += sample(u, samplerTransform(u, xy+vec2(i, j))) * sample(u, samplerTransform(u, xy+vec2(i, j)));

    float size = 49.0 + divisor;
    mean  /= size;
    mean2 /= size;

    vec4 variance = vec4(sqrt(mean2 - (mean * mean))); // sqrt(pow(pixel - mean, vec4(2.0)));
    vec3 sd       = vec3(mix(variance.rgb, variance.rgb / pixel.rgb, amount));

    return premultiply(normalize(vec4(mix(sd, sd / pixel.rgb, amount), pixel.a)));


After the image is processing by the kernel, the result is then subtracted from the original.

Other uses: Revealing your inner demon using the Gaussian + Laplacian high-pass filter
Because possessing demons also emit EMF radiation that causes chroma in digital images, any noise-isolating/enhancing filter, such as the Gaussian + Laplacian high-pass filter, will enhance images of them; like in the past, the camera and/or subject must be in motion for the demon to be seen.

Following are still frames from a third video made today, which were processed by the aforestated filter:
The demon possessing me was the first post to explore this kind of imaging in-depth; search this blog for demon possession for more.

Future development plans
A high-pass filter is one of four basic frequency domain filters, which isolate, sharpen and/or otherwise filter and enhance a specific frequency of an image—in this case, the frequency containing the noise. Generally, the only type of frequency domain filter used specifically for noise is the low-pass filter, which is primarily used to eliminate noise from an image by smoothing a specific image frequency while leaving the remainder intact (unsmoothed).
NOTE | Astute readers may have noted that the Gaussian blur is a low-pass filter; however, what makes it a component of a high-pass filter like the one demonstrated in this post is its subtraction from the original (unblurred) image.
The plan is to include all four types, along with any relevant and necessary variants, with an decloaking iPhone camera app, now in-development.