Post AnH3mD4OPSu4WUlNwm by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
(DIR) More posts by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
(DIR) Post #AnH3gR53PCiOEsJrH6 by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-22T19:27:05.176Z
1 likes, 0 repeats
If you're looking to inspect the properties of #TIFF files using a #console tool, there are several options available for various #operating systems Here are some of the most common tools you can use:### 1. ImageMagickImageMagick is a powerful command-line tool for image manipulation and inspection. #### Installation:- On macOS: brew install imagemagick- On Ubuntu: sudo apt install imagemagick- On Windows: Download from ImageMagick's official website.#### Usage:You can use the identify command to inspect TIFF properties. identify -verbose file.tiffThis command will provide detailed information about the TIFF file, including size, color type, compression type, and more.### 2. ExifToolExifTool is a very popular Perl library and command-line application for reading and writing metadata.#### Installation:- On macOS: brew install exiftool- On Ubuntu: sudo apt install exiftool- On Windows: Download from ExifTool's official website.#### Usage:You can inspect TIFF properties using:exiftool file.tiffThis will display all available metadata for the TIFF file, including EXIF data, IPTC, XMP, etc.### 3. tiffinfo (libtiff)tiffinfo is a command-line utility that comes with the libtiff library. It provides a summary of the TIFF file.#### Installation:- On Ubuntu: sudo apt install libtiff-tools- On macOS: brew install libtiff- Windows users can find pre-compiled binaries.#### Usage:To inspect a TIFF file, run:tiffinfo file.tiffThis command will give you information about the image dimensions, data types, compression, and more.### SummaryThese tools will allow you to inspect the properties and metadata of TIFF files directly from the command line. Choose the one that fits your requirements best, based on the specific details you want to view or manipulate.
(DIR) Post #AnH3mD4OPSu4WUlNwm by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-22T19:28:08.062Z
1 likes, 0 repeats
You can apply a color tint to a TIFF file using #Python with libraries like Pillow (PIL) or OpenCV. Below, I'll provide a simple example using Pillow, which is a user-friendly library for image processing.### Step 1: Install the Required LibraryFirst, make sure you have Pillow installed. You can install it using pip if you haven't already:pip install Pillow### Step 2: Create a Script to Apply Color TintHere's a simple script that opens a #TIFF file, applies a #color tint, and saves the tinted image:from PIL import Imagedef apply_tint(image_path, output_path, tint_color): # Open the image img = Image.open(image_path).convert("RGBA") # Create a new image for the tints tinted = Image.new("RGBA", img.size) # Apply the tint to each pixel for x in range(img.width): for y in range(img.height): r, g, b, a = img.getpixel((x, y)) # Apply tint color r = int(r * tint_color[0]) g = int(g * tint_color[1]) b = int(b * tint_color[2]) tinted.putpixel((x, y), (r, g, b, a)) # Save the tinted image tinted.save(output_path, format='TIFF')if __name__ == "__main__": # Define the tint color as a tuple (R, G, B) where each value is between 0 and 1 tint_color = (1.0, 0.5, 0.5) # Apply a red tint apply_tint("input_image.tiff", "output_image.tiff", tint_color)### Explanation of the Script:1. Imports: The script imports the necessary Image class from the Pillow library. 2. Function Definition: The apply_tint() function takes three parameters: the input image path, the output image path, and the tint color.3. Open Image: It opens the input TIFF image and converts it to "RGBA" format to handle transparency.4. Create Tinted Image: It creates a new blank image of the same size as the input image.5. Apply Tint: For every pixel, it adjusts the red, green, and blue values by multiplying them with the specified tint color. The tint color should be given as a tuple with values from 0 to 1 for each color channel.6. Save Image: Finally, it saves the tinted image as a TIFF file.### UsageReplace "input_image.tiff" with the path to your TIFF file and specify the desired output path in "output_image.tiff". You can adjust tint_color based on the tint effect you want to achieve.### Note:This script works for RGBA images and multiplies the color values to apply the tint. You can modify the tint_color tuple to achieve different tints (e.g., (0.5, 0.5, 1.0) would give a blue tint). Adjustments can also be made based on specific needs, such as different blending modes or efficiencies, especially for larger images.
(DIR) Post #AnH3rVyPYQbYbDUkng by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-22T19:29:03.348Z
1 likes, 0 repeats
To convert a #TIFF image to grayscale in #Python you can use the Pillow library (a fork of the Python Imaging Library). Below is a simple script that will open a TIFF file, convert it to grayscale, and then save the result.### Step 1: Install PillowIf you haven't installed Pillow yet, you can install it via pip:pip install Pillow### Step 2: Create a Script to Convert to GrayscaleHere is a simple script that converts a TIFF image to grayscale:from PIL import Imagedef convert_to_grayscale(input_path, output_path): # Open the TIFF image img = Image.open(input_path) # Convert the image to grayscale grayscale_img = img.convert("L") # Save the grayscale image grayscale_img.save(output_path, format='TIFF')if __name__ == "__main__": # Specify your input and output file paths input_image_path = "input_image.tiff" # Replace with your input TIFF file output_image_path = "output_image.tiff" # The output will also be a TIFF file convert_to_grayscale(input_image_path, output_image_path)### Explanation of the Script:1. Import: The script imports the Image class from the Pillow library.2. Function Definition: The convert_to_grayscale() function takes two parameters: the path of the input TIFF image and the path for the output grayscale image.3. Open Image: It opens the input TIFF image.4. Convert to Grayscale: The convert("L") function converts the image to grayscale. The mode "L" stands for luminance, which produces a grayscale image.5. Save Image: Finally, it saves the grayscale image as a TIFF file.### Usage1. Replace "input_image.tiff" with the path to your input TIFF file.2. Specify your desired output file path in "output_image.tiff".### Running the ScriptYou can run this script from your terminal or command prompt. Make sure the TIFF file you want to convert is in the correct path, or provide an absolute path to the file. After running, the specified output file will contain the grayscale version of the input TIFF image.This simple approach leverages Pillow's built-in functionality to handle image format conversions efficiently.
(DIR) Post #AnH3y3DIsgA3QgZrk0 by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-22T19:30:14.532Z
1 likes, 0 repeats
The convert() method in the Pillow library can change the mode of an image to various formats. Below is a list of the most commonly used modes that you can specify when using img.convert():### Common Image Modes Supported by convert()1. "1": - 1-bit pixels, black and white, stored with one pixel per byte.2. "L": - Luminance, a grayscale image with 8 bits per pixel. Shades of gray ranging from black (0) to white (255).3. "P": - Palette-based image (8-bit pixels), which uses a color palette.4. "RGB": - True color image with 3 bytes per pixel (Red, Green, Blue). The values are in the range [0, 255].5. "RGBA": - True color image with an additional alpha channel for transparency (4 bytes per pixel: Red, Green, Blue, Alpha).6. "CMYK": - Color image in the CMYK color space (Cyan, Magenta, Yellow, Black). Commonly used for printing.7. "YCbCr": - Color space typically used in video and digital photography. It separates the image's luminance from chrominance.8. "LAB": - CIE L*a*b*, a color space that represents colors in a manner more aligned with human vision.9. "HSV": - Hue, Saturation, Value color space, representing colors in terms of their hue, saturation, and brightness.10. "I": - 32-bit signed integer pixels.11. "F": - 32-bit floating point pixels.### Example UsageYou can specify one of these modes when calling the convert() method, like so:img_rgb = img.convert("RGB")img_cmyk = img.convert("CMYK")### Special Notes- Not All Modes Are Compatible: When converting between certain modes, Pillow may not preserve all image quality or attributes (like transparency) if the target mode does not support them.- Paletted Images: If you're working with images that use a palette (mode "P"), you can also pass a palette during conversion using convert("P", palette=Image.ADAPTIVE).- Performance Considerations: Converting images between different modes can sometimes result in loss of data, and certain types of conversions (like from RGB to CMYK) might not always yield expected results unless you are targeting a specific application (like preparation for printing).### Further InformationTo get the latest information on supported modes and options, you can refer to the official Pillow documentation. This will provide details on any updates or changes in newer versions of the library.
(DIR) Post #AnHT74nCsQxzmrlsps by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-23T00:12:01.653Z
1 likes, 0 repeats
For a given line, y = mx, that crosses points (1,1) and (10, mx + 10), I wish to bow the function as an exponential curve. How can I customize the amount of bending and still have it cross (1,1) and (10, mx + 10) ?To transform a linear function y = mx into an exponential curve that still passes through the points (1, 1) and (10, mx + 10), you can use an exponential function of the form y = a \cdot b^x + c .Here's a step-by-step approach to customize the amount of bending while ensuring the curve passes through the given points:1. Identify the general form of the exponential function: \[ y = a \cdot b^x + c \]2. Use the given points to set up equations: - For the point (1, 1): \[ 1 = a \cdot b^1 + c \] - For the point (10, mx + 10): \[ mx + 10 = a \cdot b^{10} + c \]3. Solve for the constants a, b, and c: - From the first point (1, 1): \[ 1 = a \cdot b + c \quad \text{(Equation 1)} \] - From the second point (10, mx + 10): \[ mx + 10 = a \cdot b^{10} + c \quad \text{(Equation 2)} \]4. Subtract Equation 1 from Equation 2 to eliminate c: \[ mx + 10 - 1 = a \cdot b^{10} - a \cdot b \] \[ mx + 9 = a \cdot (b^{10} - b) \]5. Solve for a: \[ a = \frac{mx + 9}{b^{10} - b} \]6. Substitute a back into Equation 1 to solve for c: \[ 1 = \left(\frac{mx + 9}{b^{10} - b}\right) \cdot b + c \] \[ c = 1 - \left(\frac{mx + 9}{b^{10} - b}\right) \cdot b \]7. Customize the amount of bending by choosing different values for b: - The base b controls the curvature of the exponential function. - For b > 1, the curve will bend upwards. - For 0 < b < 1, the curve will bend downwards.8. Example calculation: - Choose a value for b, say b = 1.1 for an upward bend. - Calculate a and c using the chosen b.By following these steps, you can create an exponential curve that passes through the points (1, 1) and (10, mx + 10) and customize the amount of bending by adjusting the value of b.
(DIR) Post #AnHU52NYyncng0Mu3M by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-23T00:22:51.976Z
1 likes, 0 repeats
You can blend two TIFF images with identical dimensions using the Pillow library in Python. Below is a sample script that takes two TIFF images and combines them using customizable transparency levels for both images.### PrerequisitesMake sure you have Pillow installed, as mentioned earlier:pip install Pillow### Python Script to Superimpose Two TIFF ImagesHere is a script that superimposes two TIFF images with customizable transparency:from PIL import Imagedef blend_images(image_path1, image_path2, output_path, alpha1, alpha2): # Open the images and convert them to RGBA img1 = Image.open(image_path1).convert("RGBA") img2 = Image.open(image_path2).convert("RGBA") # Ensure both images have the same size if img1.size != img2.size: raise ValueError("Both images must have the same dimensions.") # Create a new image for the blended output blended_image = Image.new("RGBA", img1.size) # Blend the images for x in range(img1.width): for y in range(img1.height): # Get the pixel values of both images pixel1 = img1.getpixel((x, y)) pixel2 = img2.getpixel((x, y)) # Apply the alpha for each image blended_pixel = ( int(pixel1[0] * alpha1 + pixel2[0] * alpha2), int(pixel1[1] * alpha1 + pixel2[1] * alpha2), int(pixel1[2] * alpha1 + pixel2[2] * alpha2), min(int(pixel1[3] * alpha1 + pixel2[3] * alpha2), 255) # Ensure alpha is clamped ) blended_image.putpixel((x, y), blended_pixel) # Save the blended image blended_image.save(output_path, "TIFF") print(f"Blended image saved to: {output_path}")if __name__ == "__main__": # Define the paths to your TIFF images input_image1 = "image1.tiff" # Change this to your first input file input_image2 = "image2.tiff" # Change this to your second input file output_image = "blended_image.tiff" # Change this to desired output file # Define alpha values for both images (0 to 1) alpha1 = 0.5 # Transparency of the first image alpha2 = 0.5 # Transparency of the second image # Blend the images blend_images(input_image1, input_image2, output_image, alpha1, alpha2)
(DIR) Post #AnHU6lQ50ODPenMvKa by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-23T00:23:06.882Z
1 likes, 0 repeats
### Explanation1. Opening Images: The script opens both TIFF images and converts them to RGBA format to accommodate transparency.2. Dimension Check: It checks that both images have the same dimensions; if not, it raises a ValueError.3. Blending Logic: It loops through each pixel of the images, applying the specified transparency levels (alpha1 for the first image and alpha2 for the second image). The new pixel values are computed by blending the corresponding pixel values of the two images.4. Saving the Result: The final blended image is saved as a new TIFF file.### Usage1. Change image1.tiff and image2.tiff to the paths of your input TIFF files.2. Set the alpha1 and alpha2 values, which define the transparency of each image. Values should range from 0 (completely transparent) to 1 (completely opaque).3. Run the script, and it will save the blended image with the specified output filename.### Note- Ensure that the two images you are blending have the same dimensions and format for this script to work correctly.- The alpha values will affect how much of each image shows in the blended output. You can adjust them to get the visual result you desire.
(DIR) Post #AnHUyPh5zq4ruiuTcO by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-23T00:32:50.132Z
0 likes, 0 repeats
Consider a simple 9x9 grid of #integer #numbers, as a #CSV Please tell me how to perform a simple #ANOVA considering 9 subgroupings, of 3x3 grids, in #PythonTo perform a simple ANOVA (Analysis of Variance) on a 9x9 grid of integer numbers, where you want to consider 9 subgroups of 3x3 grids from the larger grid, you can use the scipy library in Python. Below are the steps to achieve this along with a sample Python code:### Steps to Perform ANOVA on Subgroups1. Import Necessary Libraries: You'll need numpy for numerical operations and scipy.stats for the ANOVA function.2. Load the CSV: Read the CSV file containing the 9x9 grid into a numpy array.3. Extract 3x3 Grids: Create 9 subgroups from the 9x9 grid, each representing a 3x3 section.4. Perform One-Way ANOVA: Use scipy.stats.f_oneway() to perform the ANOVA on the extracted 3x3 grids.5. Interpret Results: Check the F-statistic and p-value to determine if there's a significant difference between the group means.### Sample Codeimport numpy as npimport pandas as pdfrom scipy import stats# Step 1: Load the CSV into a numpy array# Replace 'your_file.csv' with the actual CSV filenamedata = pd.read_csv('your_file.csv', header=None)grid = data.values # Convert DataFrame to numpy array# Step 2: Extract 3x3 gridssubgroups = []for i in range(0, 9, 3): # Iterate over rows in steps of 3 for j in range(0, 9, 3): # Iterate over columns in steps of 3 subgroup = grid[i:i+3, j:j+3].flatten() # Extract a 3x3 grid and flatten it subgroups.append(subgroup)# Step 3: Perform One-Way ANOVAf_statistic, p_value = stats.f_oneway(*subgroups)# Step 4: Output the resultsprint(f"F-statistic: {f_statistic}")print(f"P-value: {p_value}")# Step 5: Interpret the resultsalpha = 0.05if p_value < alpha: print("Reject the null hypothesis - there are significant differences between group means.")else: print("Fail to reject the null hypothesis - no significant differences between group means.")### Explanation:1. Data Loading: Replace 'your_file.csv' with the path to your CSV file containing the 9x9 grid.2. Subgroup Extraction: The loop goes through the grid in 3-row, 3-column increments to extract each 3x3 grid, flattening it into a one-dimensional array for ANOVA.3. ANOVA: The f_oneway() function takes the extracted subgroups and returns the F-statistic and p-value.4. Significance Testing: An alpha level of 0.05 is commonly used to decide whether to reject the null hypothesis.### Notes:- Ensure you have the necessary libraries installed. If not, you can install them with pip install numpy pandas scipy.- Adjust the alpha level according to your specific needs for statistical significance.@puppygo@daepi.so
(DIR) Post #AnHWbb4Njh0kRV39KC by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-23T00:51:09.749Z
0 likes, 0 repeats
There are several reputable Python libraries for conducting tests to determine whether there are statistically significant differences in variance among groups. Here are some of the most commonly used libraries and the respective tests they support for variance analysis:### 1. SciPyThe scipy library provides several statistical functions, including tests specifically for variance.- Levene's Test: Tests whether the variances are equal across groups. ```python from scipy.stats import levene stat, p_value = levene(group1, group2, group3) ```- Bartlett's Test: Tests the null hypothesis that k samples have equal variances. ```python from scipy.stats import bartlett stat, p_value = bartlett(group1, group2, group3) ```- Brown-Forsythe Test: A robust test for equality of variances that is less sensitive to departures from normality. ```python from scipy.stats import levene # Brown-Forsythe test uses Levene's test with median stat, p_value = levene(group1, group2, group3, center='median') ```### 2. PingouinPingouin is a statistical package designed for hypothesis testing and can perform various statistical tests including those for variance.- Levene's Test: ```python import pingouin as pg results = pg.homoscedasticity(data=your_dataframe, dv='dependent_variable', group='group_variable') ```### 3. Statsmodelsstatsmodels is another powerful library dedicated to statistical modeling and hypothesis testing.- While statsmodels does not have built-in functions specifically for variance tests, you can use it alongside scipy for comprehensive analysis of variance when fitting Linear Models. ### 4. PyMC3 / PyMCIf you're interested in Bayesian approaches, you can use PyMC for more complex statistical modeling, including variance analysis.- For example, you can estimate variance using hierarchical models, but this could be more advanced than traditional frequentist methods.### 5. sklearnWhile sklearn is primarily focused on machine learning, it can sometimes be used indirectly to evaluate variance (e.g., through normalization techniques or clustering methods).### ConclusionFor most classical tests of variance, SciPy and Pingouin are the most straightforward choices. They provide easy-to-use functions for Levene's and Bartlett's tests. Choose the library and method based on your specific needs (e.g., type of data distribution, number of samples) and the kind of conclusions you wish to draw from your analysis. Always ensure to check the assumptions underlying each test before interpreting the results.
(DIR) Post #AnHXNvKbhsA1BPgPZ2 by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-23T00:59:51.621Z
0 likes, 0 repeats
Detecting statistically significant outliers clustered together in a grid (or matrix) of integers can be approached using various methods, especially focusing on spatial distribution and clustering of outliers. Here’s a step-by-step guide on how to achieve this using Python, assuming your data is already imported as a 9x9 matrix.### Step 1: Import Libraries and Load DataYou'll need a few libraries for numerical processing, visualization, and clustering:import numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.cluster import DBSCANfrom scipy import statsMake sure to load your CSV data into a NumPy array or Pandas DataFrame:# Load your data (assuming the CSV is structured correctly)data = pd.read_csv('your_data.csv', header=None).values # Load as NumPy array### Step 2: Identify OutliersYou can use a statistical method such as Z-score or IQR (Interquartile Range) to identify outliers in the dataset.#### Using Z-score# Flatten the data to perform outlier detectionflattened_data = data.flatten()# Calculate Z-scoresz_scores = np.abs(stats.zscore(flattened_data))# Define a threshold for identifying outliersthreshold = 3 # Common thresholdoutlier_indices = np.where(z_scores > threshold)[0] # Indices of outliers in flattened data# Get the x, y coordinates of the outliers in the 2D gridoutlier_coordinates = np.array(np.unravel_index(outlier_indices, data.shape)).T### Step 3: Clustering the OutliersTo detect clusters of these outliers, you can use clustering algorithms like DBSCAN:#### Apply DBSCAN# Using DBSCAN for clusteringdbscan = DBSCAN(eps=1, min_samples=2) # eps=1 for neighboring pointsclusters = dbscan.fit_predict(outlier_coordinates)# Filter clusters that are not noiseclustered_outliers = outlier_coordinates[clusters != -1]### Step 4: Analyze and Visualize ClustersNow that you have identified potential clusters of outliers, you can visualize them to get a clearer understanding.# Create a scatter plot to visualize outlier locationsplt.figure(figsize=(8, 8))plt.imshow(data, cmap='viridis', interpolation='nearest')plt.colorbar()plt.scatter(outlier_coordinates[:, 1], outlier_coordinates[:, 0], color='red', label='Outliers')plt.title('Outliers in the Data Grid')plt.xlabel('Column Index')plt.ylabel('Row Index')plt.legend()plt.show()### Step 5: Output ClustersOptionally, you could print the clustered outlier coordinates:for cluster in set(clusters): if cluster != -1: # Ignore noise points cluster_indices = np.where(clusters == cluster)[0] print(f'Cluster {cluster}: {outlier_coordinates[cluster_indices]}')
(DIR) Post #AnHXPb2S7rQwpDzNho by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-23T01:00:12.028Z
0 likes, 0 repeats
### SummaryThis approach identifies outliers based on their statistical properties and then uses a clustering method to detect those that are spatially proximate. By visualizing the data, you can confirm whether the clustered outliers are meaningful in the context of your dataset.Feel free to adjust parameters like the outlier detection threshold in Z-score and eps in DBSCAN based on your specific dataset characteristics.
(DIR) Post #AnHXdKgxhOUEBIUFUm by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-10-23T01:02:40.754Z
0 likes, 0 repeats
The line clusters = dbscan.fit_predict(outlier_coordinates) is a key step in using the DBSCAN (Density-Based Spatial Clustering of Applications with Noise) algorithm for clustering your outlier data points. Let's break it down to understand what it does and how it works:### Components Breakdown1. DBSCAN Object: - dbscan is an instance of the DBSCAN class from the sklearn.cluster module. Before this line, you would typically have created this instance and configured parameters: ```python dbscan = DBSCAN(eps=1, min_samples=2) ``` - Here, eps (epsilon) is the maximum distance between two samples for them to be considered as in the same neighborhood, and min_samples is the minimum number of samples in a neighborhood for a point to be classified as a core point.2. fit_predict Method: - The fit_predict method is a convenience method provided by many clustering algorithms in scikit-learn, including DBSCAN. It takes care of two things at once: - Fit the Model: It computes the clustering based on the input data. This means it analyzes the outlier_coordinates to find dense regions (clusters) based on the configured parameters (eps and min_samples). - Predict Cluster Labels: It assigns a cluster label to each point in the input data. Points that are classified as part of a cluster receive a non-negative integer label (e.g., 0, 1, 2, etc.), while points that don't belong to any cluster (noise points) are labeled as -1.3. Input Data (outlier_coordinates): - The input here is outlier_coordinates, which is an array of coordinates (row and column indices) corresponding to the outlier points in the original 9x9 grid. Each point in outlier_coordinates is considered in the clustering process.### What Happens After Execution- The result of dbscan.fit_predict(outlier_coordinates) is stored in the variable clusters. This variable will contain an array of the same length as outlier_coordinates, with each entry corresponding to the cluster label of the respective point: - Points belonging to the same cluster will have the same label. - Points that are considered noise (not part of any cluster) will have a label of -1.### ExampleFor example, if your outlier_coordinates contained five points, and the output in clusters was [0, 0, -1, 1, 1], it would mean:- The first two points belong to the same cluster labeled 0.- The third point is noise (outlier) and does not belong to any cluster.- The fourth and fifth points belong to a different cluster labeled 1.### SummaryIn summary, the line clusters = dbscan.fit_predict(outlier_coordinates) is essential for using the DBSCAN algorithm to find and label clusters among a set of identified outlier points based on their spatial proximity. The resulting clusters array can be used for further analysis, such as evaluating the nature of clustered outliers or visualizing the results.
(DIR) Post #ApLUjTObuIH3HmYHZo by gfkdsgn@burma.social
2024-12-23T18:32:31Z
1 likes, 1 repeats
Wow! I wonder why you @KuteboiCoder are so into this dinosaur of file formats. It's even older than TGA afaik.Most likely you know more about the lib than I do. How is it compared to GraphicsMagick?
(DIR) Post #ApLUtjQNAVaFtQGfce by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-12-23T18:35:04.219Z
0 likes, 0 repeats
@gfkdsgn@burma.social it's a #FOSS implementation, with #AI -authored code, for pixel-level manipulation. I wanted a raw, uncompressed image file format.Forgot what I was trying to do with it
(DIR) Post #ApLV7UvNsKEAycKysy by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-12-23T18:37:32.495Z
0 likes, 0 repeats
@gfkdsgn@burma.social I believe it was me trying to reverse-engineer some depth detection and edge detection, for training an genAI image model totally from scratchIt's all in my head really, haven't gotten very far with code
(DIR) Post #ApLVDM6bZptLMXNZGy by gfkdsgn@burma.social
2024-12-23T18:38:15Z
1 likes, 1 repeats
@KuteboiCoderIt supports a lossless length compression by Ziff Davis as far as I remember.
(DIR) Post #ApLVRQnIwQArxU3ytM by Ai2ObsFjnLcY8CdUMi.KuteboiCoder@subs4social.xyz
2024-12-23T18:41:09.801Z
0 likes, 0 repeats
@gfkdsgn@burma.social I don't really give a shit about image generation, right now, because there's so many freaking porno coomers glutting the market with new models and LoRAs. I'm never gonna get rich or famous competing in that space.I'm more interested in learning about cloud and IaaS DevOps. That's how you ultimate scale-up or scale-down AI models, or A/B test different models side by side.That's going to be something I pay attention to learning in the very near future. I've already signed up for a class.
(DIR) Post #ApLW0TdWMkVUuPCLpY by ax3@wizard.casa
2024-12-23T18:45:12.421586Z
2 likes, 1 repeats
@KuteboiCoder consider mat2mat2 --show file.png # displays properties and exifmat2 --inplace file.png # wipes properties and exif inline