int main(int argc,char *argv[])
{
if (argc==2 && (strcmp(argv[1],"-help")==0))
{
showHelp();
return 0;
}
if (argc!=4)
{
Warning("Zle zadane argumenty\n");
showHelp();
return 1;
}
struct ppm *ppmFile=ppm_read(argv[1]);
if (ppmFile==NULL)
{
FatalError("Chyba citania zo suboru");
return 1;
}
EncodeMessage(ppmFile,argv[3]);
if (ppm_write(ppmFile,argv[2])!=0)
{
free(ppmFile);
Warning("Zapis do suboru sa nepodaril");
return 1;
}
free(ppmFile);
return 0;
}
static int
load_ppm (app_t *self, const char *filename)
{
FILE *fp = fopen (filename, "rb");
if (!fp) { perror ("fopen"); return -1; }
int status = ppm_read (fp, &self->img, &self->img_width, &self->img_height,
&self->img_stride);
fclose (fp);
return status;
}
int main(int argc, const char* argv[])
{
if (argc != 2) {
FatalError("Neplatne argumenty programu!");
}
struct ppm* image = ppm_read(argv[1]);
if (!image) {
return EXIT_FAILURE;
}
BA_create(bit_array, N);
Eratosthenes(bit_array);
int ch, nbits;
ch = nbits = 0;
unsigned long image_size = image->xsize * image->ysize * 3;
for (unsigned long i = 2; i < image_size; i++) {
if (BA_get_bit(bit_array, i) == 0) {
/** :) kdyz najdeme prvocislo tak to znamena ze
* v poli image->data mame v LSB bitu v bajtu
* na indexu i ulozeny jeden bit znaku zakodovane
* zpravy
*/
// n-ty bit (nbits) znaku (ch) nastavime na hodnotu LSB bitu
// prvociselne polozky pole image->data
DU1_SET_BIT((&ch), nbits, DU1_GET_BIT((&image->data[i]), 0));
if((++nbits) == CHAR_BIT) { // mame j*z cely znak?
if (ch == 0) {
break;
} else if (isprint(ch)) {
printf("%c", ch);
nbits = 0;
} else {
FatalError("Zprava obsahuje netisknutelny znak!");
}
}
}
}
free(image);
return EXIT_SUCCESS;
}
void
ppm_printf(struct ppm * ppm)
{
int i, j;
color_t color;
for(i = 0; i < ppm->height; i++)
{
for(j = 0; j < ppm->width; j++)
{
color = ppm_read(ppm, j, i);
printf("(%'3d, %'3d) %'3d %'3d %'3d;", j, i, color.red, color.green, color.blue);
}
printf("\n");
}
}
/*
* pic_read: read a TIFF or PPM file into memory.
* Normally, you should use opic==NULL.
* If opic!=NULL, then picture is read into opic->pix (after checking that
* size is sufficient), else a new Pic is allocated.
* Returns Pic pointer on success, NULL on failure.
*/
Pic *pic_read(char *file, Pic *opic)
{
switch( pic_file_type(file) )
{
case PIC_TIFF_FILE:
//return tiff_read(file, opic);
break;
case PIC_PPM_FILE:
return ppm_read(file, opic);
break;
case PIC_JPEG_FILE:
//return jpeg_read(file, opic);
break;
default:
return NULL;
}
}
icv_image_t *
icv_read(const char *filename, int format, int width, int height)
{
if (format == ICV_IMAGE_AUTO) {
/* do some voodoo with the file magic or something... */
format = ICV_IMAGE_PIX;
}
switch (format) {
case ICV_IMAGE_PIX:
return pix_read(filename, width, height);
case ICV_IMAGE_BW :
return bw_read(filename, width, height);
case ICV_IMAGE_DPIX :
return dpix_read(filename, width, height);
case ICV_IMAGE_PPM :
return ppm_read(filename);
default:
bu_log("icv_read not implemented for this format\n");
return NULL;
}
}
int main( int argc, char *argv[] )
{
struct image image;
struct qti compimage;
struct tilecache *cache;
int opt, verbose;
unsigned long int insize, bsize, outsize;
unsigned long int cacheblocks, cachehits;
int transform, colordiff;
int rangecomp;
int minsize;
int maxdepth;
int lazyness;
int cachesize;
char *infile, *outfile;
verbose = 0;
transform = 0;
colordiff = 0;
rangecomp = 0;
minsize = 2;
maxdepth = 16;
cachesize = 0;
lazyness = 0;
infile = NULL;
outfile = NULL;
while( ( opt = getopt( argc, argv, "hevy:t:s:d:c:l:i:o:" ) ) != -1 )
{
switch( opt )
{
case 'h':
print_help();
return 0;
break;
case 't':
if( sscanf( optarg, "%i", &transform ) != 1 )
fputs( "main: Can not parse command line: -t\n", stderr );
break;
case 'e':
rangecomp = 1;
break;
case 'y':
if( sscanf( optarg, "%i", &colordiff ) != 1 )
fputs( "main: Can not parse command line: -y\n", stderr );
break;
case 'v':
verbose = 1;
break;
case 's':
if( sscanf( optarg, "%i", &minsize ) != 1 )
fputs( "main: Can not parse command line: -s\n", stderr );
break;
case 'd':
if( sscanf( optarg, "%i", &maxdepth ) != 1 )
fputs( "main: Can not parse command line: -d\n", stderr );
break;
case 'c':
if( sscanf( optarg, "%i", &cachesize ) != 1 )
fputs( "main: Can not parse command line: -c\n", stderr );
break;
case 'l':
if( sscanf( optarg, "%i", &lazyness ) != 1 )
fputs( "main: Can not parse command line: -l\n", stderr );
break;
case 'i':
infile = strdup( optarg );
break;
case 'o':
outfile = strdup( optarg );
break;
default:
case '?':
fputs( "main: Can not parse command line: unknown option\n", stderr );
return 1;
break;
}
}
if( ( transform < 0 ) || ( transform > 2 ) )
{
fputs( "main: Transform mode out of range\n", stderr );
return 1;
}
if( ( colordiff < 0 ) || ( colordiff > 2 ) )
{
fputs( "main: Fakeyuv mode out of range\n", stderr );
return 1;
}
if( minsize < 0 )
{
fputs( "main: Mininmal block size out of range\n", stderr );
return 1;
}
if( maxdepth < 0 )
{
fputs( "main: Maximum recursion depth out of range\n", stderr );
return 1;
}
if( cachesize < 0 )
{
fputs( "main: Cache size out of range\n", stderr );
return 1;
}
if( lazyness < 0 )
{
fputs( "main: Lazyness recursion depth out of range\n", stderr );
return 1;
}
if( ! ppm_read( &image, infile ) ) // Read the input image
return 2;
insize = image.width * image.height * 3;
if( colordiff >= 1 ) // Apply fakeyuv transform
image_color_diff( &image );
if( transform == 1 ) // Apply image transforms
image_transform_fast( &image );
else if( transform == 2 )
image_transform( &image );
if( cachesize > 0 )
cache = tilecache_create( cachesize*1024, minsize ); // Create tile cache
else
cache = NULL;
if( ! qti_create( &compimage, image.width, image.height, minsize, maxdepth, cache ) )
return 2;
if( ! qtc_compress( &image, NULL, &compimage, lazyness, colordiff >= 2 ) ) // Compress the image
return 2;
bsize = qti_getsize( &compimage );
if( ! ( outsize = qti_write( &compimage, rangecomp, outfile ) ) ) // Write image to file
return 2;
image_free( &image );
qti_free( &compimage );
if( cache != NULL )
{
cacheblocks = cache->numblocks;
cachehits = cache->hits;
tilecache_free( cache );
}
else
{
cacheblocks = 0;
cachehits = 0;
}
if( verbose )
fprintf( stderr, "In:%luB Buff:%luB,%f%% Cache:%lu/%lu,%f%% Out:%luB,%f%%\n",
insize, bsize/8, (bsize/8)*100.0/insize,
cachehits, cacheblocks, cachehits*100.0/cacheblocks,
outsize, outsize*100.0/insize );
free( infile );
free( outfile );
return 0;
}
int main(int argc, char *argv[])
{
if (argc == 2) // ak nie je zadany chybny pocet argumentov
{
struct ppm *picture = ppm_read(argv[1]); // nacitanie struktury
char sprava = 0,index2=0,bit;
unsigned long index;
int nullbyte = 0;
if (picture == NULL) // ak nacitanie skoncilo s chybou
FatalError("Chybne zadany subor\n");
BitArray(bitmap,LIMIT); // iniciaizacia bit. pola
Eratosthenes(bitmap); // vypocet prvociselnych indexov
for (index=2;index <= (LIMIT); index++)
{
if (GetBit(bitmap,index) == 0) // prvociselny index
{
bit = DU1_GET_BIT((&(picture->data)[index+1]),0); // vyber LSB z bytu
DU1_SET_BIT((&sprava),index2,bit); // nastav na nasledujuci index vybrany bit
if (index2 < (BYTE - 1)) // ci uz nie je zaplneny cely byte
{
index2++;
}
else if ((sprava != '\0') && (isprint(sprava))) // ak nie je znak nulovy alebo netlacitelny
{
printf("%c",sprava); // vytlaci 1 znak zo spravy
index2 = 0; // vynulue pocet nast. bitov a znak
sprava = 0;
}
else if (sprava == '\0') // ak je znak nulovy -> koniec spravy
{
printf("\n");
nullbyte = 1;
break;
}
else // ak je znak netlacitelny -> fatal error
{
free(picture);
FatalError("Sprava ulozena v subore: %s nie je korektna\n",argv[1]);
}
}
}
if (nullbyte == 0)
{
free(picture);
FatalError("Sprava ulozena v subore: %s nie je korektne ukoncena\n",argv[1]);
return 1;
} else
{
free(picture); // uvolnenie alokovanej pamate
return 0;
}
} else
{
FatalError("Nespravne zadane argumenty\n");
return 1;
}
}
int main(int argc, char* argv[]) {
/* Arguments */
if (argc != 3 ) {
printf("\nUsage: %s <file> <clusters count> \n\n", argv[0]);
return 0;
}
ppm_t* src = ppm_read(argv[1]);
int clusters_count = atoi(argv[2]);
if (clusters_count < 2) {
printf("\nParameter <clusters count> must be greater than 1 (got %s)\n", argv[2]);
return 0;
}
cluster_data* clusters = malloc(clusters_count * sizeof(cluster_data));
for (int i = 0; i < clusters_count; i++) {
clusters[i].count = 0;
clusters[i].red_sum = 0;
clusters[i].green_sum = 0;
clusters[i].blue_sum = 0;
// Choose initial cluster centers randomly
clusters[i].center = (color) {
rand() % src->maxval,
rand() % src->maxval,
rand() % src->maxval
};
}
/*
// Forced initial three
clusters[0].center = (color) { 255, 83, 201 };
clusters[1].center = (color) { 222, 219, 64 };
clusters[2].center = (color) { 0, 0, 0 };
*/
int* pixel_cluster = malloc(src->cols * src->rows * sizeof(int));
for (;;) {
bool modified = false;
for (int i = 0; i < src->rows; i++) {
for (int j = 0; j < src->cols; j++) {
color c = PPM_AT(src, i, j);
int min_distance_sq = INT_MAX;
int min_cluster = -1;
for (int cluster = 0; cluster < clusters_count; cluster++) {
color center = clusters[cluster].center;
int dred = center.red - c.red;
int dgreen = center.green - c.green;
int dblue = center.blue - c.blue;
int distance_sq = dred * dred + dgreen * dgreen + dblue * dblue;
if (distance_sq < min_distance_sq) {
min_cluster = cluster;
min_distance_sq = distance_sq;
}
}
if (pixel_cluster[i * src->cols + j] != min_cluster) {
pixel_cluster[i * src->cols + j] = min_cluster;
modified = true;
}
clusters[min_cluster].count++;
clusters[min_cluster].red_sum += c.red;
clusters[min_cluster].green_sum += c.green;
clusters[min_cluster].blue_sum += c.blue;
}
}
if (!modified) {
break;
}
for (int i = 0; i < clusters_count; i++) {
if (clusters[i].count > 0) {
clusters[i].center.red = clusters[i].red_sum;
clusters[i].center.red /= clusters[i].count;
clusters[i].center.green = clusters[i].green_sum / clusters[i].count;
clusters[i].center.blue = clusters[i].blue_sum / clusters[i].count;
}
clusters[i].count = 0;
clusters[i].red_sum = 0;
clusters[i].green_sum = 0;
clusters[i].blue_sum = 0;
}
}
ppm_t* dst = ppm_create_empty(src->cols, src->rows, src->maxval);
for (int i = 0; i < src->rows; i++) {
for (int j = 0; j < src->cols; j++) {
int cluster = pixel_cluster[i * src->cols + j];
PPM_AT(dst, i, j) = clusters[cluster].center;
}
}
ppm_write(dst, true);
return 0;
}
