In photoshop - you have random noise generators like "clouds" and "difference clouds". The idea I had was - what would happen if I generated both of these filters on each RGB channel and then also use black and white clouds on all RBG channels. Also with level adjustments & sharpening and desaturation - I found the results quite interesting. At first - I didn't get any results, but then i remembered you can save what you do in photoshop as an "action" - So I began recording my action and recreated the steps again. - Now I can just simply hit F11, or F12 keys to generate the image instantly. (yes, I created two versions of the actions) which both give different results.

Below will show a few Images I captured. Some might be cropped, and some are the full originals.

If anybody has a Windows PC with a webcam (or one they can attach), and wants to experiment with visual ITC, let me know.

Here's a screenshot of the program:

The two "tricks" then for getting things to work is to derive as much noise as possible from the camera, and then apply our favorite transformation that either blurs or "smokifies" the noise.

How do you get lots of noise from a camera? Well, one way would be turn up the gain and exposure time, and put the camera in complete darkness. Another more universal method is to simply subtract the current frame from the previous frame. This allows us to point the camera at virtually anything (or nothing at all) and get a noisy pattern.

Here's an example from a webcam. I've mathematically amplified the noise so you can see it. 

Now the next trick is to somehow make heads or tails of the noise. Blurring is one possibility, which could be done with something called Gaussian kernel convolution in image manipulation programs like GIMP and Photoshop. However, even better than that is "smokification." That's a word I just made up, but it's like how Perlin noise is created from regular white noise. White noise is fairly featureless and looks like indistinguishable sand, but Perlin noise often produces cloudy / smoky-like textures like the ones you see in Keith's Perlin image experiments.

Now, I've been trying out different variations on Perlin, like my so-called "Perloids" but the general range of useful ones seem to be between "inverse frequency" and "inverse squared frequency" What this means in laymans terms is that we try to transform noise to look as real as possible using essentially a two dimension "graphic equalizer" (you know, the audio version for controlling high, mid, and low frequencies?)

Now imagine amplifying the "bass frequencies" (or the largest features of an image) and keeping the mid-levels in the middle, and dampening out  the "treble/high frequencies" (the smallest features). This is the essence of Perlinizing / smokifying noise - and the results are amazing as we've seen with Perlin noise images, and continue to be with my webcam/noise input.

Incidentally, the original Varanormal France Perlin program uses random numbers generated with a deterministic algorithm, although a non-deterministic seed. How spirits figured out how send messages through that channel puzzles me to this day, but it seems to work. Here I'm using physically-generated noise (from a webcam), so at least it seems plausible that spirits could influence the electronics or the light in the air to send us information.

And now for some pictures. Caveat emptor: I can't prove that anything we see here is really from spirit, and not just active imagination. But I'm hoping over time, the proof will either get clearer, or we'll have too many instances to dismiss.

The first two are from a camera I got in the mail today, and they're a bit disappointing. But what you might see in black and white are four faces followed by one face. The next four small ones are faces. The final one on the 2nd row appears to have at least four faces. 

The last row is a little different. The first one is a whole body image. The second looks like a humanoid-alien face. The final one is an example of when I point the camera at myself and hold real still. Maybe we'll start being able to view the personalities of our soul?

One very last comment for this post. There's no machine learning tricks in the method (yet?!?), just "simple" math.

Therefore, I figured out a similar idea without this artifact. Although the pictures (with pseudorandom noise) are not quite as cool, it does have a very "fractally" nature to it.

#---------------------------------
# Original author: Michael S. Lee
# Date: 9/18/2021
#---------------------------------

import numpy as np
import imageio
import cv2
from scipy.signal import convolve,get_window
import matplotlib.pyplot as plt

def shrink(x, gamma = 30):
    beta = gamma / (x.std())
    y = 1.0 / (1.0 + np.exp(-beta*(x-x.mean())))
    return(y)
    
N = 1024 # Image size

noise = np.random.rand(N,N,3) # White noise in RGB channels
noise2 = np.copy(noise) # setup output array
noise2 = cv2.resize(noise2,(1024,1024))
noise2 = noise
image = noise2

blur = np.copy(image)
sum1 = np.zeros_like(image)
thresh = 0.375

i = 1024

num_levels = 19
factor = 3/4

for j in range(num_levels):
   
   blur2 = blur
   ii = ((i+1) // 2) * 2
   blur = cv2.GaussianBlur(noise2, (ii-1,ii-1), 0) #convolve(noise2,kernel3,'same')
   
   if (j > 0):
     diff = blur - blur2
     diff = shrink(diff, gamma = 25)
     sum1 = sum1 + (i**0.25)*diff 
   #sum1 = sum1 + diff
   print (i)
   i = int(i * factor)
   
sum1 = (sum1 - sum1.min())/ (sum1.max()-sum1.min())
sum1 = sum1 ** 3

# Save on disk
index = np.random.randint(0,262144) # Random filename
imageio.imsave('temp.'+str(index)+'.png',sum1)

The first few images are "regular" sort of Perlin-like, but as you get 5-9, the thresholding is increase for each color channel and resolution channel. It ends producing almost natural-like features. It is it ITC, mathematics in action, or both?

Code: 

#---------------------------------
# Original author: Michael S. Lee
# Date: 8/27/2021
#---------------------------------

import numpy as np
import matplotlib.pyplot as plt
import cv2

N = 1024 # Image size
noise = np.random.rand(N,N,3) # White noise in RGB channels
noise2 = np.copy(noise) # setup output array

image = noise2
blur = np.copy(image)
sum1 = np.zeros_like(image)

for j,i in enumerate([512,256,128,64,32,16,8,4,2]):

   image = cv2.resize(noise2,(i,i),interpolation=cv2.INTER_LANCZOS4)
   blur2 = blur
   blur = cv2.resize(image,(N,N))
   diff = blur - blur2
   min1 = diff.mean() - 1.0*diff.std()
   max1 = diff.mean() + 1.0*diff.std()
   diff = np.clip((diff - min1)/(max1-min1),0,1)
   sum1 = sum1 + (j+1)*diff

min1 = sum1.mean() - 2.0*sum1.std()
max1 = sum1.mean() + 2.0*sum1.std()

sum1 = np.clip((sum1 - min1) / (max1-min1),0,1)
plt.imshow(sum1)

plt.show()

It is preferred that pictures are 1MB or less, when possible.

Thanks!

Varanormal Team

Part of a dog's face

A very faint human face(front side)