Documentation

All commands start with .img, followed by the chosen arguments
the command structure requires the use of [ and ] wrapping the relevant args to an image edit/command
i/e: '.img resize [ overlaying [ shake :googleturtle: jpeg3 [ hcjHH 2 ] ] 80 ]'
or: '.img resize [ :emoji: 80 ]'
if a command/edit only requires 1 input, it doesn't need [] wrapping
if a command/edit requires a string input and has any spaces, it will need [ wrapping ]
MAKE SURE THERE ARE SPACES BETWEEN ALL ELEMENTS
in any place, where a command/edit has an image input, it can have a nested command/edit placed
image inputs can also be discord emoji, unicode emoji, and urls
'duration' in the case of gifs tends to be in loops per default gif duration

recently used commands can be edited and have the output changed to reflect the changes in the command

>intense [ [ string ] int(intensity level) ]
outputs a gif of the input string, shaking as strongly as the input int

>speed [ [ string ] int ]
outputs a gif of the input string, with each space-separated 'word' flashing by at speed of int

>mocking [ [ string ] ]
outputs an image of mocking spongebob with subtitles of string

>space [ image(gif/png) ]
outputs the chosen image flying through space

>shoot [ image(gif/png) ]
meme of pepe with a gun shooting bullets of the image

>italics [ image(gif/png) ]
outputs a slanted image of the input

>jpeg [ image(gif/png) ]
outputs a fried image of the input

>man [ image(gif/png) ]
outputs a meme of an emoji-constituted man jerking off, with the head replaced by input image

>jpeg2 [ image(gif/png) int(loops: 0-inf) ]
outputs a deep-fried image of the input intensity

>jpeg3 [ image(gif/png) int(loops: 0-inf) ]
outputs a blurry/jpegified image of input intensity

>weee [ image(png) ]
outputs a looping/spinning/panning/tiling image of the input

>shake [ image(gif/png) ]
outputs a shaking/quaking animation of the input

>shake2 [ image(png) float(intensity) ]
shake, but with no rotation

>nuke [ image(gif/png) ]
outputs a nuke animation of the input image

>moreshake [ image(gif/png) ]
same as shake, but stronger

>hold [ image(gif/png) ]
outputs a meme of the man who can't hold all his lemons, but with the lemons replaced by the input image

>hold2 [ image(gif/png) ]
same as above, but gifs get a random playback offset

>hold3 [ image(png) image(png) image(png) ]
same as hold, but can accept an arbitrary number of image inputs, does a 'fair' scramble on their placement

>overlay [ image(png) image/string(png) ]
outputs the first image, overlayed by a roughly centered second input image/string corresponding to image
valid strings are mask, maskF, hazmat, hazmatF?

>overlay2 [ image(png) image/string(png) x(pixels) y(pixels) rot(degrees?) scale(1 being normal) ]
same as above, but with extra args for position, rotation, and scale adjustment

>4head [ image(gif/png) int ]
outputs a warped image, based on the input int. Low values inflate, larger/negative ones go weird and warpy.

>wormhole [ image(gif/png) ]
based on 4head, but each frame has a different int value

>peek [ image(gif/png) ]
outputs the input image 'peeking' up

>peek2 [ image(gif/png) float(0-1) ]
sameish as above, but with an input of 1, makes a full peek, while 0.5 is half peek

>rotate [ image(gif/png) int(degrees) ]
self-explanatory, rotates the image by input degrees

>flip [ image(gif/png) ]
left-to-right mirror of image

>hyper [ image(gif/png) int(delay) ]
outputs an image that flips left-to-right repeatedly with input delay between flips

>info [ image(gif/png) ]
outputs a string of various values describing the image, like size and metadata

>8ball
theoretically outputs a string of randomized magic 8ball outputs, but probably broken

>snap [ image(png) ]
thanos snaps the image

>snap2 [ image(gif/png) ]
thanos snaps the image, now with gif support

>snap3 [ image(gif/png) [iterations default of 2, minimum 1] [modifier default of 60] [modifier default of 25] ]
same as above, but configurable. If using defaults, it outputs similar as snap2

>snap4 [ image(gif/png) int int int ]
can't remember what makes this different to the above

>3d [ image(gif/png) yaw roll pitch ]
outputs a 3d view of the image on a flat plane. The plane rotates depending on the inputs, with 0 being no rotation.

>3dlit [ image(gif/png) yaw roll pitch int(red 0-255) int(blue 0-255) int(green 0-255) ]
same as above, but with an RGB-colored spotlight

>wide [ image(gif/png) ]
outputs the input image, but wider

>resize [ image(gif/png) int(pixels) ]
outputs the input image, but rescaled so the largest dimension width/height is equal to the input pixels

>wobble [ image(gif/png) int(delay) ]
outputs a wobbling image of the input, wobbling to the input int frequency, with lower being faster(for png), but otherwise being a multiple of the gif duration, with 1 being 1 loop and 2 being 2 times in 1 loop

>crop [ image(gif/png) int(0-1) ]
crops off a portion of the image from the edges, with 1 being the whole image and 0 being none

>shrink [ image(gif/png) int(velocity) int(z offset) ]
outputs an image in 3d space, walking at velocity in z, starting at an offset. negative velocity is toward the camera, positive offset is farther from the camera, with 0 being camera position

>think [ image(gif/png) x(pixels) y(pixels) float(scale) ]
overlays a thinking finger with offset x and y, scale of input, overtop the input image

>alpha [ image(png) float(0-1) ]
outputs the input image, but with the alpha of each pixel multiplied by the input, with 1 being the same and 0 being complete transparency

>illegal [ image(png) int(duration(probably want 30 or 40ish)) ]
outputs the input image, but with a flashing colored spotlight to simulate police lights, with the flashing modified by the duration

>append [ image(gif) image(gif) ]
outputs the second gif added onto the end of the first

>atmograph [ int(seconds) ]
outputs a graph of the atmospheric data from my room, from now to input seconds ago

>areyousure [ image(png) ]
outputs a meme of john cena green-screened into the input image

>justdoit [ image(png) ]
same as above, but with the justdoit meme

>couch [ image(png) ]
naked man exits couch as above

>manydoors [ image(png) ]
there are many doors, ed-boy

>mask [ image(gif/png) int(red 0-255) int(green 0-255) int(blue 0-255) int(hue 0-360) int(Hue 0-100) int(Sat 0-100) int(Vol 0-100) ]
takes the input pixels of the image, and for those that are within a percent hue saturation and value of the input RGB, changes them to match the input Hue

>mask2 [ image(gif/png) int(red 0-255) int(green 0-255) int(blue 0-255) int(duration) int(Hue 0-100) int(Sat 0-100) int(Vol 0-100) ]
same as above, but a rainbowy gif modified by duration

>mask3 [ image(gif/png) image(gif/png) int(green 0-255) int(blue 0-255) int(Hue 0-100) int(Sat 0-100) int(Vol 0-100) ]
uses similar logic as the above, but uses it to exchange the pixels of two images

>mask4 [ image(gif/png) int(duration) ]
full-image hue-offset based rainbow effect based on duration

>overlaying [ image(gif/png) image(gif/png) ]
overlaying one over the other, with a bit of resizing logic so the background image meets the edges

>lcd [ image(gif/png) ]
outputs the input image, with each pixel turned into a 6x6 rgb lcd pixel

>lcd2 [ image(gif/png) ]
same as above, but with a dark opaque background

>lcd3 [ image(gif/png) int(noise 0-?) ]
same as lcd2, but outputs a gif image with simulated white noise in the image, 0 as the input makes it identical to lcd2

>crt4 [ image(gif/png) width(pixels) height(pixels) int(resolution 1-?, 3 default) int(noise 0-?) ]
Turns the input image into a crt displaying the input. 4th iteration, and most true to life.

>crt [ image(gif/png) width(pixels) height(pixels) ]
initial implementation, outputs a png of a crt displaying the input

>crt2 [ image(gif/png) width(pixels) height(pixels) int(noise 0-?)
outputs a gif version, with animated image noise

>ntsc [ image(gif/png) int(pixel split) ]
outputs the input in NTSC colorspace with the colors out of horizontal alignment

>pad [ image(gif/png) int(red 0-255) int(green 0-255) int(blue 0-255) int(alpha 0-255) float(padding, 0 being none) ]
outputs the input image on a square background of input RGBA, with the input amount of extra width/height proportional.

>stereo [ image(png) float(default 5, adjusts perceived depth) ]
outputs a machine-learning based cross-eye stereogram of the input image

>stereo2 [ image(png) ]
outputs the depthmap output of the aforementioned machine-learning as an image, with hue? representing depth

>stereo3 [ image(png) image(png) ]
generates a stereogram of the first image, using the second image as a depth map

>emboss [ image(gif/png) ]
outputs the image after an emboss filter

>aggressive [ image(gif/png) ]
a combined shaking/rainbow effect that I made for some reason

>border [ image(gif/png) float(pixels, roughly) ]
gives the input image a black border of width input pixels

>border2 [ image(gif/png) float(width) int(red 0-255) int(blue 0-255) int(green 0-255) int(alpha 0-255) ]
same as above, with input RGBA for colors

>enchant [ image(png) ]
gives the input image a minecraft enchantment glint overlay

>upscale [ image(gif/png) ]
pixel perfect 2x upscale

>downscale [ image(gif/png) ]
nearest filter 0.5x downscale

.get_palettes returns a list of available entries for the following commands

>palette [ image(gif/png) string(palette) ]
outputs the input image with floyd-steinberg dithering in the input palette

>palette2 [ image(gif/png) string(palette) ]
same as above, but a special adobe dithering algorithm instead

>palette3 [ image(gif/png) string(palette) ]
same as above, but simple ordered dithering

>stitchw [ image(png) ... ]
stitches the input images together horizontally

>stitchh [ image(png) ... ]
same as above, but vertically

>brightness [ image(gif/png) float(0-?) ]
adjusts image brightness, with 1 being no change

>contrast [ image(gif/png) float(0-?) ]
same as above, for contrast

>saturation [ image(gif/png) float(0-?) ]
same as above, for saturation

>blur [ image(gif/png) float(0-?) ]
gaussian blur of input intensity

>diffract [ image(gif/png) width(pixels) ]
horizontally offsets the RGB channels from eachother, widening the image to do so

>glitch [ image(gif/png) int(iterations) float(chance, default .95) ]
flips bits of the input image as a jpeg to make glitch art. iterations is how many bits are flipped, chance is for gifs and adjusts image stability, with closer to 1 being more stable

>gifify [ image(png) int(delay, multiples of 10 but 20 minimum) int(frames) ]
turns the input image into a gif with input delay per number of input frames

>jitter [ image(gif/png) int(pixel height) ]
randomly vertically offsets the image, with gifs being per-frame

>invert [ image(gif/png) ]
inverts the image colors

>spin [ image(gif/png) int(frames for png, times for gif) ]
spins the input image, outputting a gif. static images take input frames to go a full spin, input gifs spin input number of times per gif duration

>pumpkin [ image(gif/png) ]
outputs a jackolantern with the input image carved into it

>pumpkin2 [ image(gif/png) ]
same as above, but dark

>imagine [ string ]
outputs the spongebob imagine meme, with the input text arcing across the rainbow ]