|
|
Post by nathanmyersc on Feb 1, 2024 3:05:07 GMT
I created an intention repeater in c++ that searches the intention you type for a object to charge or image to charge if it finds one and you are imbuing the item with an INTENTIONS.txt It will read each line of that intentions.txt affirming the object is charged with the intentions of each individual intention in intentions.txt If it doesnt detect the word Charged then it presumes currently that the benificiary is me and reads each line of INTENTIONS.txt with the foreword of my name recieving the intentions i dont recall how i worded it atm. I think its a cool take on things. not sure if any of your programs actually read the lines of the text file as affirmations to the charged object or person. its a good idea i think. Its highly beta but here it is for anyone who has a c++ compiler. "Satans Bane.jpg" is Charged with the intentions of "INTENTIONS.txt" is how i operate it currently. The program will detect that Satans Bane.jpg is the object of charging. and that INTENTIONS.txt are the intentions. It iterates overy every line of INTENTIONS.txt intending it to go charge Satans Bane.jpg in my example. There is a iteration counter. But much slower iterations than your model as it is reading the entire INTENTIONS document of text every loop. Im sure il find more ways to improve it ecetera. It looks for a certain list of keywords Charged charged imbued Imbued will mean that the charged object preceeds it Charging charging Imbuing imbuing imbues and Imbues will mean that the charged object proceeds it. Use accordingly. AKA "INTENTIONS.txt is charging "PERSON A" with its affirmations. or "PERSON A" is charged with the affirmations within "INTENTIONS.txt" QOUTATIONS are mandatory. #include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <thread>
#include <atomic>
#include <windows.h>
#include <array>
const std::array<std::string,4> chargeWordsPastTense = { "Charged", "charged", "Imbued", "imbued"};
const std::array<std::string,6> chargeWordsFutureTense = {"Charging", "charging", "Imbuing", "imbuing","imbues","Imbues"};
// Global vector to hold intentions from text files
std::vector<std::string> intentions;
std::string chargingFile = "";
std::string chargedObject = "Nathan Douglas Myerscough";
volatile long long fileReadLoops = 0;
volatile long long maxLongLongReads = 0;
const long long maxLongLongSize = 9223372036854775806;
// Function to load text file into a vector of strings
void loadTextFile(const std::string& filename) {
std::ifstream file(filename);
std::string line;
while (std::getline(file, line)) {
intentions.push_back(line);
}
}
// Function to load image file
void loadImageFile(const std::string& filename) {
chargedObject = filename;
// Add code here to load image file
std::cout << "Loading image file: " << filename << std::endl;
}
// Function to load audio file
void loadAudioFile(const std::string& filename) {
chargedObject = filename;
// Add code here to load audio file
std::cout << "Loading audio file: " << filename << std::endl;
}
void extractChargedName(const std::string& input, const size_t startQuote, const size_t endQuote)
{
std::string fileName = input.substr(startQuote + 1, endQuote - startQuote - 1);
// Assuming the preceding file is more likely an image or audio file
std::string extension = chargingFile.substr(chargingFile.find_last_of(".") + 1);
std::cout << extension;
if (extension == "jpg" || extension == "png" || extension == "gif") {
loadImageFile(fileName);
} else if (extension == "mp3" || extension == "wav" || extension == "ogg") {
loadAudioFile(fileName);
}
else
{
chargedObject = fileName;
}
}
void backSearchForChargedObject(const std::string& input, const size_t chargedPos)
{
// Search for the file preceding the "Charged" keyword
size_t endQuote = input.rfind("\"", chargedPos);
if (endQuote != std::string::npos) {
size_t startQuote = input.rfind("\"",endQuote-1);
if (startQuote != std::string::npos) {
extractChargedName(input, startQuote,endQuote);
}
}
}
void forwardSearchForChargedObject(const std::string& input, const size_t chargedPos)
{
// Search for the file preceding the "Charged" keyword
size_t startQuote = input.find("\"", chargedPos);
if (startQuote != std::string::npos) {
size_t endQuote = input.find("\"",startQuote+1);
if (endQuote != std::string::npos) {
extractChargedName(input,startQuote,endQuote);
}
}
}
// Function to search for file names in input string
void searchAndLoadFiles(const std::string& input) {
size_t chargedPos;
for (const auto& word : chargeWordsPastTense) {
chargedPos = input.find(word);
if (chargedPos != std::string::npos) {
backSearchForChargedObject(input,chargedPos);
// Search for a text file after the "Charged" keyword
size_t pos = (chargedPos != std::string::npos ? chargedPos + 7 : 0); // Start searching after "Charged"
if((pos = input.find(".txt", pos)) != std::string::npos) {
size_t end = pos + 4;
size_t start = input.rfind("\"", pos-1) + 1;
chargingFile = input.substr(start, end - start);
loadTextFile(chargingFile);
}//ELSE its a one line affirmation figure it out somehow.
return;
}
}
if (chargedPos == std::string::npos) {
for(const auto& word: chargeWordsFutureTense){
chargedPos = input.find(word);
if (chargedPos != std::string::npos) {
forwardSearchForChargedObject(input,chargedPos);
}
}
}
size_t pos = (chargedPos != std::string::npos ? chargedPos : input.size()-1); // Start searching after "Charged"
if((pos = input.rfind(".txt", pos)) != std::string::npos) {
size_t end = pos + 4;
size_t start = input.rfind("\"", pos-1) + 1;
chargingFile = input.substr(start, end - start);
loadTextFile(chargingFile);
}
}
void iterationTimeCounter()
{
fileReadLoops += 1;
SetConsoleTitleA(std::__cxx11::to_string(fileReadLoops + (maxLongLongReads*maxLongLongSize)).c_str());
if(fileReadLoops == maxLongLongSize)
{
fileReadLoops = 0; maxLongLongReads += 1;
}
}
std::vector<std::string>* modifiedIntentions;
// Function to modify intentions when chargedFile is not empty
void modifyChargedIntentions() {
modifiedIntentions = new std::vector<std::string>();
for (const auto& intent : intentions) {
modifiedIntentions->push_back(chargedObject + " is imbued with the following intention: " + intent);
//std::cout <<modifiedIntentions.back() << std::endl;
}
delete modifiedIntentions; iterationTimeCounter();
}
// Function to modify intentions when chargedFile is empty
void modifyPersonIntentions() {
modifiedIntentions = new std::vector<std::string>();
for (const auto& intent : intentions) {
modifiedIntentions->push_back(chargedObject + " is imbued with the following intention: " + intent);
}
delete modifiedIntentions; iterationTimeCounter();
}
int main() {
std::string intention;
std::cout << "Please enter your intention: ";
std::getline(std::cin, intention);
// Search for file names and load files
searchAndLoadFiles(intention);
std:: cout << "Charged Object is: " + chargedObject << std::endl;
std::cout << "Charging File is: " + chargingFile << std::endl;
if(intentions.empty())
{
intentions.push_back (intention);
}
std::atomic<bool> exitRequested(false);
//
// //Start a thread to monitor for keyboard input
// std::thread inputThread([&exitRequested]() {
// while (!exitRequested) {
// if (std::cin.peek() == 27) { // Check if the next input is the escape key
// exitRequested = true;
// }
// }
// });
do {
if(chargedObject != "")
modifyChargedIntentions();
else
modifyPersonIntentions();
} while (!exitRequested);
// inputThread.join(); // Wait for the input thread to finish
return 0;
}
Attachments:INTENTIONREPEATER.zip (551.58 KB)
|
|
|
|
Post by AnthroHeart on Feb 1, 2024 11:37:42 GMT
Cool. You could store the lines of the INTENTIONS.TXT into an array, and loop through that much faster.
|
|
|
|
Post by reden on Feb 1, 2024 14:58:11 GMT
You can use unsigned to further increase the range, from -9,223,372,036,854,775,808-9,223,372,036,854,775,807, to 18,446,744,073,709,551,614, per Microsoft, as Repeater does not need negative numbers.
|
|
|
|
Post by AnthroHeart on Feb 1, 2024 20:13:57 GMT
You can use unsigned to further increase the range, from -9,223,372,036,854,775,808-9,223,372,036,854,775,807, to 18,446,744,073,709,551,614, per Microsoft, as Repeater does not need negative numbers. The Repeater stores total number of repetitions in a string instead of an unsigned, because otherwise it reaches the limit in like 15 minutes. |
|
|
|
Post by nathanmyersc on Feb 3, 2024 17:15:59 GMT
I have found that with readin 1000s of lines of affirmations every iteration i will never reach the max number of the variable although i have considered math with strings if necessary.
You guys should look into custom metadata tags. Could be another way to set intentions.
I wrote some programs that utilize libjpeg and taglib to add custom metadata to images and audio files. and i use that to put all my affirmations into the file themselves. hidden.
|
|
|
|
Post by reden on Feb 6, 2024 0:21:40 GMT
I have found that with readin 1000s of lines of affirmations every iteration i will never reach the max number of the variable although i have considered math with strings if necessary. You guys should look into custom metadata tags. Could be another way to set intentions. I wrote some programs that utilize libjpeg and taglib to add custom metadata to images and audio files. and i use that to put all my affirmations into the file themselves. hidden. I make images using custom compiled versions of the Repeater Image Creator that generate perfectly sized images, then shift the transparency to 100%, place the perfectly sized image above the image I'm infusing, and save. The intentions become a permanent part of the file, the filesize grows to reflect this too, and it cannot be undone. |
|
|
|
Post by nathanmyersc on Feb 7, 2024 15:05:16 GMT
I have found that with readin 1000s of lines of affirmations every iteration i will never reach the max number of the variable although i have considered math with strings if necessary. You guys should look into custom metadata tags. Could be another way to set intentions. I wrote some programs that utilize libjpeg and taglib to add custom metadata to images and audio files. and i use that to put all my affirmations into the file themselves. hidden. I make images using custom compiled versions of the Repeater Image Creator that generate perfectly sized images, then shift the transparency to 100%, place the perfectly sized image above the image I'm infusing, and save. The intentions become a permanent part of the file, the filesize grows to reflect this too, and it cannot be undone. Oh cool a different form of affirmation implantation.That idea seems interesting. it involves having the affirmations programmatically bitmapped ontop an image. Then that image is overlayed by a more pleasent image. I had pondered similar things by having affirmations written behind the image or something I also found you can combine a JPG file with a ZIP file and get a JPG file. so it essentially hides whatever you want in there. I put alot of images within images this way. just a helpful visual way of affirmation for me. Its not hard to do at all. i do it programmatically but you can open a CMD and do copy /b "file.jpg+file.zip" "output.jpg" and you will have a viewable image with whatever you want to hide inside of it. Like the bmp writer you guys use is taking the affirmations and using their bits and bytes as the color information for the bit map file right? Thats a neat idea. |
|
|
|
Post by nathanmyersc on Feb 7, 2024 15:58:50 GMT
I just gave a shot at making my own form of your BMP writer. Also i used your concept of 1% or so opacity to overlay about 2000 holy fire shield intentions onto my holy fire shield mandala. Here have it. freeimage.host/i/J1ntNTBjumpshare.com/s/VckSuuwCfGsznOc0gIAdIt never seems to uploadable in the format or size i put it up in. But its hyper good stuff. Id be dead without this right now. Cause i got some serious stuff going on. But this is very powerful. Heres the audio to accompany it. Which has been infused with every single image and intention. file.io/wnf114zyb52ealso the original bmp file.io/wnf114zyb52epostimg.cc/0rfKqksw #include <iostream>
#include <fstream>
#include <cstdint>
#include <vector>
#include <algorithm>
using namespace std;
// Function to write the bitmap file header
void writeBitmapFileHeader(ofstream& file, uint32_t fileSize) {
const uint16_t bfType = 0x4D42; // "BM"
const uint32_t bfReserved = 0;
const uint32_t bfOffBits = 54; // Offset to pixel data (fixed for 24-bit RGB)
file.write(reinterpret_cast<const char*>(&bfType), sizeof(uint16_t)); // Signature
file.write(reinterpret_cast<const char*>(&fileSize), sizeof(uint32_t)); // File size
file.write(reinterpret_cast<const char*>(&bfReserved), sizeof(uint32_t)); // Reserved (unused)
file.write(reinterpret_cast<const char*>(&bfOffBits), sizeof(uint32_t)); // Offset to pixel data
}
// Function to write the bitmap information header
void writeBitmapInfoHeader(ofstream& file, uint32_t width, uint32_t height) {
const uint32_t biSize = 40; // Size of BITMAPINFOHEADER
const uint16_t biPlanes = 1; // Number of color planes
const uint16_t biBitCount = 24; // Bits per pixel (24-bit RGB)
const uint32_t biCompression = 0; // Compression method (BI_RGB for no compression)
const uint32_t biSizeImage = 0; // Image size (0 for BI_RGB)
const uint32_t biXPelsPerMeter = 0; // Horizontal resolution (pixels per meter)
const uint32_t biYPelsPerMeter = 0; // Vertical resolution (pixels per meter)
const uint32_t biClrUsed = 0; // Number of colors in the palette (0 for full color)
const uint32_t biClrImportant = 0; // Number of important colors (0 for all)
file.write(reinterpret_cast<const char*>(&biSize), sizeof(uint32_t)); // Header size
file.write(reinterpret_cast<const char*>(&width), sizeof(uint32_t)); // Image width
file.write(reinterpret_cast<const char*>(&height), sizeof(uint32_t)); // Image height
file.write(reinterpret_cast<const char*>(&biPlanes), sizeof(uint16_t)); // Color planes
file.write(reinterpret_cast<const char*>(&biBitCount), sizeof(uint16_t)); // Bits per pixel
file.write(reinterpret_cast<const char*>(&biCompression), sizeof(uint32_t)); // Compression
file.write(reinterpret_cast<const char*>(&biSizeImage), sizeof(uint32_t)); // Image size
file.write(reinterpret_cast<const char*>(&biXPelsPerMeter), sizeof(uint32_t)); // Horizontal resolution
file.write(reinterpret_cast<const char*>(&biYPelsPerMeter), sizeof(uint32_t)); // Vertical resolution
file.write(reinterpret_cast<const char*>(&biClrUsed), sizeof(uint32_t)); // Colors used
file.write(reinterpret_cast<const char*>(&biClrImportant), sizeof(uint32_t)); // Important colors
}
// Function to convert a character to its bit representation
vector<bool> charToBits(char c) {
vector<bool> bits;
for (int i = 0; i < 8; ++i) {
bits.push_back((c >> i) & 1);
}
return bits;
}
int main() {
const uint32_t width = 1920; // Image width
const uint32_t height = 1080; // Image height
const uint32_t bytesPerPixel = 3; // Bytes per pixel
const uint32_t rowSize = width * bytesPerPixel; // Size of each row in bytes
const uint32_t rowPadding = (4 - (rowSize % 4)) % 4; // Padding bytes per row to ensure alignment
const uint32_t pixelDataSize = (rowSize + rowPadding) * height; // Total size of pixel data including padding
const uint32_t totalFileSize = 54 + pixelDataSize; // Total file size including header
// Open input text file
ifstream inputFile("input.txt");
if (!inputFile) {
cerr << "Error: Unable to open input text file." << endl;
return 1;
}
// Read characters from input text file and convert to bits
vector<bool> allBits;
char c;
while (inputFile.get(c)) {
vector<bool> bits = charToBits(c);
allBits.insert(allBits.end(), bits.begin(), bits.end());
}
// Repeat the content of the input text file until it fills the required number of bits
while (allBits.size() < width * height * bytesPerPixel * 8) {
allBits.insert(allBits.end(), allBits.begin(), allBits.end());
}
// Truncate the bits vector if it exceeds the required number of bits
allBits.resize(width * height * bytesPerPixel * 8);
// Create output bitmap file
ofstream outputFile("output.bmp", ios::binary);
if (!outputFile) {
cerr << "Error: Unable to create output bitmap file." << endl;
return 1;
}
// Write bitmap file header
writeBitmapFileHeader(outputFile, totalFileSize);
// Write bitmap information header
writeBitmapInfoHeader(outputFile, width, height);
// Write pixel data (converted bits) with row padding
for (size_t i = 0; i < height; ++i) {
for (size_t j = 0; j < width; ++j) {
uint32_t pixel = 0;
for (size_t k = 0; k < bytesPerPixel * 8; ++k) {
pixel |= allBits[(i * width + j) * bytesPerPixel * 8 + k] << k;
}
outputFile.write(reinterpret_cast<const char*>(&pixel), bytesPerPixel);
}
// Write row padding
for (size_t k = 0; k < rowPadding; ++k) {
outputFile.put(0);
}
}
// Close output bitmap file
outputFile.close();
cout << "Bitmap created successfully." << endl;
return 0;
}
|
|
|
|
Post by reden on Feb 7, 2024 16:36:24 GMT
I make images using custom compiled versions of the Repeater Image Creator that generate perfectly sized images, then shift the transparency to 100%, place the perfectly sized image above the image I'm infusing, and save. The intentions become a permanent part of the file, the filesize grows to reflect this too, and it cannot be undone. Oh cool a different form of affirmation implantation.That idea seems interesting. it involves having the affirmations programmatically bitmapped ontop an image. Then that image is overlayed by a more pleasent image. I had pondered similar things by having affirmations written behind the image or something I also found you can combine a JPG file with a ZIP file and get a JPG file. so it essentially hides whatever you want in there. I put alot of images within images this way. just a helpful visual way of affirmation for me. Its not hard to do at all. i do it programmatically but you can open a CMD and do copy /b "file.jpg+file.zip" "output.jpg" and you will have a viewable image with whatever you want to hide inside of it. Like the bmp writer you guys use is taking the affirmations and using their bits and bytes as the color information for the bit map file right? Thats a neat idea. The image+zip combination sounds interesting, but the heaviness and odd data might upset some websites, who might be confused or even disallow the file. The BMP Writer works, as far as I know, by translating letters into binary code, for example "I am love" into 01001001 00100000 01100001 01101101 00100000 01101100 01101111 01110110 01100101, and etching them in a monochrome 1 bit (written as a standard 8-bit for simplicity) image. 1 bit images describe pixels as lit or unlit. Lit would be 1, unlit would be 0. Then the pattern is looped all through the rest of the file if it was too short to cover it completely. By using ImageMagick or another converter, giant 30 MB 4K BMPs are slimmed down to 30 kb PNGs, as PNG supports 1 bit images. |
|
|
|
Post by nathanmyersc on Feb 7, 2024 16:40:57 GMT
Oh cool a different form of affirmation implantation.That idea seems interesting. it involves having the affirmations programmatically bitmapped ontop an image. Then that image is overlayed by a more pleasent image. I had pondered similar things by having affirmations written behind the image or something I also found you can combine a JPG file with a ZIP file and get a JPG file. so it essentially hides whatever you want in there. I put alot of images within images this way. just a helpful visual way of affirmation for me. Its not hard to do at all. i do it programmatically but you can open a CMD and do copy /b "file.jpg+file.zip" "output.jpg" and you will have a viewable image with whatever you want to hide inside of it. Like the bmp writer you guys use is taking the affirmations and using their bits and bytes as the color information for the bit map file right? Thats a neat idea. The image+zip combination sounds interesting, but the heaviness and odd data might upset some websites, who might be confused or even disallow the file. The BMP Writer works, as far as I know, by translating letters into binary code, for example "I am love" into 01001001 00100000 01100001 01101101 00100000 01101100 01101111 01110110 01100101, and etching them in a monochrome 1 bit (written as a standard 8-bit for simplicity) image. 1 bit images describe pixels as lit or unlit. Lit would be 1, unlit would be 0. Then the pattern is looped all through the rest of the file if it was too short to cover it completely. By using ImageMagick or another converter, giant 30 MB 4K BMPs are slimmed down to 30 kb PNGs, as PNG supports 1 bit images. I just gave a shot at making my own form of your BMP writer. Also i used your concept of 1% or so opacity to overlay about 2000 holy fire shield intentions onto my holy fire shield mandala. Here have it. freeimage.host/i/J1ntNTB jumpshare.com/s/VckSuuwCfGsznOc0gIAd It never seems to uploadable in the format or size i put it up in. But its hyper good stuff. Id be dead without this right now. Cause i got some serious stuff going on. But this is very powerful. Heres the audio to accompany it. Which has been infused with every single image and intention. file.io/wnf114zyb52e also the original bmp file.io/wnf114zyb52e Very powerful magick actually if you are under attack by demons or are sick. |
|
|
|
Post by reden on Feb 7, 2024 16:54:23 GMT
If you're talking about uploading it directly here, this forum has an 1 MB upload size limit, which is a remnant of the forum software's ancient origins. Somebody would have to pay to increase it. Suddenly, my bank card was denied while renewing the Adfree subscription (one month later), but right now I tried the manual purchase and it went through. Therefore given this issue I couldn't pay for a storage increase, which is a $30 per month subscription for up to 20 MB, 30 files per post and 4 GB storage (very overpriced to boot).
|
|
|
|
Post by nathanmyersc on Feb 7, 2024 17:33:34 GMT
If you're talking about uploading it directly here, this forum has an 1 MB upload size limit, which is a remnant of the forum software's ancient origins. Somebody would have to pay to increase it. Suddenly, my bank card was denied while renewing the Adfree subscription (one month later), but right now I tried the manual purchase and it went through. Therefore given this issue I couldn't pay for a storage increase, which is a $30 per month subscription for up to 20 MB, 30 files per post and 4 GB storage (very overpriced to boot). Nah i meant the free uploading services always seem to change the format ecetera. the mandala i made is probably the most complicated ive ever seen. Its like a collage of stories. |
|
