hms
/
aptdec
spogulis no https://github.com/Xerbo/aptdec
1
0
Atdalīts 0
Kods Problēmas 0 Laidieni 7 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
39 Revīzijas
2 Atzari
1.5 MiB
 
 
 
 
 
Koks: ca80eeecc8
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no 'ca80eeecc8'
${ noResults }
aptdec/main.c

470 rindas
13 KiB
Neapstrādāts Vainot Vēsture 

  1. /*

  2.  *  Atpdec

  3.  *  Copyright (c) 2003 by Thierry Leconte (F4DWV)

  4.  *

  5.  *      $Id$

  6.  *

  7.  *   This library is free software; you can redistribute it and/or modify

  8.  *   it under the terms of the GNU Library General Public License as

  9.  *   published by the Free Software Foundation; either version 2 of

  10.  *   the License, or (at your option) any later version.

  11.  *

  12.  *   This program is distributed in the hope that it will be useful,

  13.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  15.  *   GNU Library General Public License for more details.

  16.  *

  17.  *   You should have received a copy of the GNU Library General Public

  18.  *   License along with this library; if not, write to the Free Software

  19.  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  20.  *

  21.  */

  22. 

  23. #include <stdio.h>

  24. #ifdef WIN32

  25. #include "w32util.h"

  26. #else

  27. #include <libgen.h>

  28. #endif

  29. #include <string.h>

  30. #include <sndfile.h>

  31. #include <png.h>

  32. 

  33. #include "version.h"

  34. 

  35. extern getpixelrow (float *pixelv);

  36. 

  37. #define SYNC_WIDTH 39

  38. #define SPC_WIDTH 47

  39. #define TELE_WIDTH 45

  40. #define CH_WIDTH  909

  41. #define CH_OFFSET  (SYNC_WIDTH+SPC_WIDTH+CH_WIDTH+TELE_WIDTH)

  42. #define IMG_WIDTH  2080

  43. 

  44. static SNDFILE *inwav;

  45. static int

  46. initsnd (char *filename)

  47. {

  48.   SF_INFO infwav;

  49. 

  50. /* open wav input file */

  51.   infwav.format = 0;

  52.   inwav = sf_open (filename, SFM_READ, &infwav);

  53.   if (inwav == NULL) {

  54.     fprintf (stderr, "could not open %s\n", filename);

  55.     return (1);

  56.   }

  57.   if (infwav.samplerate != 11025) {

  58.     fprintf (stderr, "Bad Input File sample rate: %d. Must be 11025\n",

  59. 	     infwav.samplerate);

  60.     return (1);

  61.   }

  62.   if (infwav.channels != 1) {

  63.     fprintf (stderr, "Too many channels in input file : %d\n",

  64. 	     infwav.channels);

  65.     return (1);

  66.   }

  67. 

  68.   return (0);

  69. }

  70. 

  71. int

  72. getsample (float *sample, int nb)

  73. {

  74.   return (sf_read_float (inwav, sample, nb));

  75. }

  76. 

  77. static png_text text_ptr[] = {

  78.   {PNG_TEXT_COMPRESSION_NONE, "Software", version, sizeof (version)}

  79.   ,

  80.   {PNG_TEXT_COMPRESSION_NONE, "Channel", NULL, 0}

  81.   ,

  82.   {PNG_TEXT_COMPRESSION_NONE, "Description", "NOAA POES satellite Image", 25}

  83. };

  84. 

  85. static int

  86. ImageOut (char *filename, char *chid, float **prow, int nrow, int depth,

  87. 	  int width, int offset)

  88. {

  89.   FILE *pngfile;

  90.   png_infop info_ptr;

  91.   png_structp png_ptr;

  92.   int n;

  93. 

  94. /* init png lib */

  95.   png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

  96.   if (!png_ptr) {

  97.     fprintf (stderr, "could not open create png_ptr\n");

  98.     return (1);

  99.   }

  100. 

  101.   info_ptr = png_create_info_struct (png_ptr);

  102.   if (!info_ptr) {

  103.     png_destroy_write_struct (&png_ptr, (png_infopp) NULL);

  104.     fprintf (stderr, "could not open create info_ptr\n");

  105.     return (1);

  106.   }

  107. 

  108.   png_set_IHDR (png_ptr, info_ptr, width, nrow,

  109. 		depth, PNG_COLOR_TYPE_GRAY, PNG_INTERLACE_NONE,

  110. 		PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

  111. 

  112.   text_ptr[1].text = chid;

  113.   text_ptr[1].text_length = strlen (chid);

  114.   png_set_text (png_ptr, info_ptr, text_ptr, 3);

  115.   png_set_pHYs (png_ptr, info_ptr, 4000, 4000, PNG_RESOLUTION_METER);

  116. 

  117.   printf ("Writing %s ... ", filename);

  118.   fflush (stdout);

  119.   pngfile = fopen (filename, "w");

  120.   if (pngfile == NULL) {

  121.     fprintf (stderr, "could not open %s\n", filename);

  122.     return (1);

  123.   }

  124.   png_init_io (png_ptr, pngfile);

  125.   png_write_info (png_ptr, info_ptr);

  126. 

  127.   for (n = 0; n < nrow; n++) {

  128.     float *pixelv;

  129.     png_byte pixel[2 * IMG_WIDTH];

  130.     int i;

  131. 

  132.     pixelv = prow[n];

  133.     for (i = 0; i < width; i++) {

  134.       float pv;

  135. 

  136.       pv = pixelv[i + offset];

  137.       switch (depth) {

  138.       case 8:

  139. 	pixel[i] = floor (pv);

  140. 	break;

  141.       case 16:

  142. 	((unsigned short *) pixel)[i] =

  143. 	  htons ((unsigned short) floor (pv * 255.0));

  144. 	break;

  145.       }

  146.     }

  147.     png_write_row (png_ptr, pixel);

  148.   }

  149.   png_write_end (png_ptr, info_ptr);

  150.   fclose (pngfile);

  151.   printf ("Done\n");

  152.   png_destroy_write_struct (&png_ptr, &info_ptr);

  153.   return (0);

  154. }

  155. 

  156. int

  157. ImageColorOut (char *filename, float **prow, int nrow)

  158. {

  159.   FILE *pngfile;

  160.   png_infop info_ptr;

  161.   png_structp png_ptr;

  162.   int n;

  163.   float *pixelc,*pixeln,*pixelp;

  164.   float pv[CH_WIDTH];

  165.   float pt[CH_WIDTH];

  166. 

  167.   extern void false_color (double v, double t, float *r, float *g, float *b);

  168.   extern void dres(

  169. 		float av, float at, float bv, float bt,

  170.   		float cv, float ct, float dv, float dt,

  171. 		float *v , float *t);

  172. 

  173. /* init png lib */

  174.   png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

  175.   if (!png_ptr) {

  176.     fprintf (stderr, "could not open create png_ptr\n");

  177.     return (1);

  178.   }

  179. 

  180.   info_ptr = png_create_info_struct (png_ptr);

  181.   if (!info_ptr) {

  182.     png_destroy_write_struct (&png_ptr, (png_infopp) NULL);

  183.     fprintf (stderr, "could not open create info_ptr\n");

  184.     return (1);

  185.   }

  186. 

  187.   png_set_IHDR (png_ptr, info_ptr, 2*CH_WIDTH-3, 2*nrow-3,

  188. 		8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,

  189. 		PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

  190. 

  191.   text_ptr[1].text = "False Colors";

  192.   png_set_pHYs (png_ptr, info_ptr, 2000, 2000, PNG_RESOLUTION_METER);

  193. 

  194.   text_ptr[1].text_length = strlen (text_ptr[1].text);

  195.   png_set_text (png_ptr, info_ptr, text_ptr, 3);

  196. 

  197.   printf ("Computing False colors & writing : %s ...", filename);

  198.   fflush (stdout);

  199.   pngfile = fopen (filename, "w");

  200.   if (pngfile == NULL) {

  201.     fprintf (stderr, "could not open %s\n", filename);

  202.     return (1);

  203.   }

  204.   png_init_io (png_ptr, pngfile);

  205.   png_write_info (png_ptr, info_ptr);

  206. 

  207.   pixelc=NULL;pixeln=prow[0];

  208. 

  209.   for (n = 0; n < nrow-1; n++) {

  210.     png_color pixa[2*CH_WIDTH];

  211.     png_color pixb[2*CH_WIDTH];

  212.     int i;

  213. 

  214.     pixelp=pixelc;pixelc=pixeln;pixeln=prow[n+1];

  215. 

  216.     for (i = 0; i < CH_WIDTH-1; i++) {

  217.       float av,bv,cv,dv;

  218.       float at,bt,ct,dt;

  219.       float pvc,ptc; 

  220.       float v,t; 

  221.       float r, g, b;

  222.     

  223.       av = pixelc[i+SYNC_WIDTH + SPC_WIDTH];

  224.       bv = pixeln[i+SYNC_WIDTH + SPC_WIDTH];

  225.       cv = pixelc[i+1+SYNC_WIDTH + SPC_WIDTH];

  226.       dv = pixeln[i+1+SYNC_WIDTH + SPC_WIDTH];

  227.       if(n!=0) {

  228.       at = 0.667*pixelc[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET]

  229.            + 0.333*pixelp[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  230.       bt = 0.667*pixeln[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET]

  231.            + 0.333*pixelc[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  232.       ct = 0.667*pixelc[i+1+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET]

  233.           + 0.333*pixelp[i+1+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  234.       dt = 0.667*pixeln[i+1+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET]

  235.            + 0.333*pixelc[i+1+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  236.       } else  {

  237.       at = pixelc[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  238.       bt = pixeln[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  239.       ct = pixelc[i+1+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  240.       dt = pixeln[i+1+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  241.       }

  242. 

  243.       dres (av,at,bv,bt,cv,ct,dv,dt,&v,&t);

  244. 

  245.       falsecolor (v, t, &r, &g, &b);

  246.       pixb[2*i].red = (unsigned int) (255.0 * r);

  247.       pixb[2*i].green = (unsigned int) (255.0 * g);

  248.       pixb[2*i].blue = (unsigned int) (255.0 * b);

  249. 

  250.       pvc=v;ptc=t;

  251. 

  252.       if(n!=0) {

  253.       av = pv[i];

  254.       bv = pixelc[i+SYNC_WIDTH + SPC_WIDTH];

  255.       cv = pixelc[i+1+SYNC_WIDTH + SPC_WIDTH];

  256.       dv = pvc;

  257.       at = pt[i];

  258.       bt = 0.667*pixelc[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET]

  259.            + 0.333*pixelp[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  260.       ct = 0.667*pixelc[i+1+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET]

  261.            + 0.333*pixelp[i+1+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  262.       dt = ptc;

  263. 

  264.       dres (av,at,bv,bt,cv,ct,dv,dt,&v,&t);

  265. 

  266.       falsecolor (v, t, &r, &g, &b);

  267.       pixa[2*i].red = (unsigned int) (255.0 * r);

  268.       pixa[2*i].green = (unsigned int) (255.0 * g);

  269.       pixa[2*i].blue = (unsigned int) (255.0 * b);

  270.       } 

  271.       pv[i]=pvc;pt[i]=ptc;

  272. 

  273.       if (i!=0) {

  274. 

  275.       if (n!=0) {

  276.       v = pixelc[i+SYNC_WIDTH + SPC_WIDTH];

  277.       t = 0.667*pixelc[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET]

  278.            + 0.333*pixelp[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  279.       falsecolor (v, t, &r, &g, &b);

  280.       pixa[2*i-1].red = (unsigned int) (255.0 * r);

  281.       pixa[2*i-1].green = (unsigned int) (255.0 * g);

  282.       pixa[2*i-1].blue = (unsigned int) (255.0 * b);

  283.       }

  284. 

  285.       av = pixelc[i+SYNC_WIDTH + SPC_WIDTH];

  286.       bv = pv[i-1];

  287.       cv = pvc;

  288.       dv = pixeln[i+SYNC_WIDTH + SPC_WIDTH];

  289.       if(n!=0) {

  290.       at = 0.667*pixelc[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET]

  291.            + 0.333*pixelp[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  292.       dt = 0.667*pixeln[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET]

  293.            + 0.333*pixelc[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  294.       } else {

  295.       at = pixelc[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  296.       dt = pixeln[i+SYNC_WIDTH + SPC_WIDTH + CH_OFFSET];

  297.       }

  298.       bt = pt[i-1];

  299.       ct = ptc;

  300.       

  301.       dres (av,at,bv,bt,cv,ct,dv,dt,&v,&t);

  302. 

  303.       falsecolor (v, t, &r, &g, &b);

  304.       pixb[2*i-1].red = (unsigned int) (255.0 * r);

  305.       pixb[2*i-1].green = (unsigned int) (255.0 * g);

  306.       pixb[2*i-1].blue = (unsigned int) (255.0 * b);

  307.       }

  308. 

  309.     }

  310.     if(n!=0) png_write_row (png_ptr, (png_bytep) pixa);

  311.     png_write_row (png_ptr, (png_bytep) pixb);

  312. 

  313.   }

  314.   png_write_end (png_ptr, info_ptr);

  315.   fclose (pngfile);

  316.   printf ("Done\n");

  317.   png_destroy_write_struct (&png_ptr, &info_ptr);

  318.   return (0);

  319. }

  320. 

  321. extern int Calibrate (float **prow, int nrow, int offset);

  322. extern int Temperature (float **prow, int nrow, int ch, int offset);

  323. extern void readfconf (char *file);

  324. extern int optind, opterr;

  325. extern char *optarg;

  326. int satnum = 1;

  327. 

  328. static void

  329. usage (void)

  330. {

  331.   fprintf (stderr, "atpdec [options] soundfiles ...\n");

  332.   fprintf (stderr,

  333. 	   "options:\n-d <dir>\tDestination directory\n-i [a|b|c|t]\tOutput image type\n\t\t\tr: Raw\n\t\t\ta: A chan.\n\t\t\tb: B chan.\n\t\t\tc: False color\n\t\t\tt: Temperature\n-c <file>\tFalse color config file\n-p\t\t16bits output\n-s [0|1]\tSatellite id (for temperature and false color generation)\n\t\t\t0:NOAA15\n\t\t\t1:NOAA17\n");

  334. }

  335. 

  336. main (int argc, char **argv)

  337. {

  338.   char pngfilename[1024];

  339.   char name[1024];

  340.   char pngdirname[1024] = "";

  341.   char imgopt[20] = "ac";

  342.   float *prow[3000];

  343.   char *chid[6] = { "1", "2", "3A", "4", "5", "3B" };

  344.   int depth = 8;

  345.   int n, nrow;

  346.   int ch;

  347.   int c;

  348. 

  349.   printf ("%s\n", version);

  350. 

  351.   opterr = 0;

  352.   while ((c = getopt (argc, argv, "c:d:i:ps:")) != EOF) {

  353.     switch (c) {

  354.     case 'd':

  355.       strcpy (pngdirname, optarg);

  356.       break;

  357.     case 'c':

  358.       readfconf (optarg);

  359.       break;

  360.     case 'i':

  361.       strcpy (imgopt, optarg);

  362.       break;

  363.     case 'p':

  364.       depth = 16;

  365.       break;

  366.     case 's':

  367.       satnum = atoi (optarg);

  368.       if (satnum < 0 || satnum > 1) {

  369. 	fprintf (stderr, "invalid satellite\n");

  370. 	exit (1);

  371.       }

  372.       break;

  373.     default:

  374.       usage ();

  375.     }

  376.   }

  377. 

  378.   for (nrow = 0; nrow < 3000; nrow++)

  379.     prow[nrow] = NULL;

  380. 

  381.   for (; optind < argc; optind++) {

  382.     int a = 0, b = 0;

  383. 

  384.     strcpy (pngfilename, argv[optind]);

  385.     strcpy (name, basename (pngfilename));

  386.     strtok (name, ".");

  387.     if (pngdirname[0] == '\0') {

  388.       strcpy (pngfilename, argv[optind]);

  389.       strcpy (pngdirname, dirname (pngfilename));

  390.     }

  391. 

  392. /* open snd input */

  393.     if (initsnd (argv[optind]))

  394.       exit (1);

  395. 

  396. /* main loop */

  397.     printf ("Decoding: %s \n", argv[optind]);

  398.     for (nrow = 0; nrow < 3000; nrow++) {

  399.       if (prow[nrow] == NULL)

  400. 	prow[nrow] = (float *) malloc (sizeof (float) * 2150);

  401.       if (getpixelrow (prow[nrow]) == 0)

  402. 	break;

  403.       printf ("%d\r", nrow);

  404.       fflush (stdout);

  405.     }

  406.     printf ("\nDone\n", nrow);

  407.     sf_close (inwav);

  408. 

  409. /* raw image */

  410.     if (strchr (imgopt, (int) 'r') != NULL) {

  411.       sprintf (pngfilename, "%s/%s-r.png", pngdirname, name);

  412.       ImageOut (pngfilename, "raw", prow, nrow, depth, IMG_WIDTH, 0);

  413.     }

  414. 

  415. /* Channel A */

  416.     if (((strchr (imgopt, (int) 'a') != NULL)

  417. 	 || (strchr (imgopt, (int) 'c') != NULL)

  418. 	 || (strchr (imgopt, (int) 'd') != NULL))) {

  419.       ch = Calibrate (prow, nrow, SYNC_WIDTH);

  420.       if (ch >= 0) {

  421. 	if (strchr (imgopt, (int) 'a') != NULL) {

  422. 	  sprintf (pngfilename, "%s/%s-%s.png", pngdirname, name, chid[ch]);

  423. 	  ImageOut (pngfilename, chid[ch], prow, nrow, depth,

  424. 		    SPC_WIDTH + CH_WIDTH + TELE_WIDTH, SYNC_WIDTH);

  425. 	}

  426.       }

  427.       if (ch < 2)

  428. 	a = 1;

  429.     }

  430. 

  431. /* Channel B */

  432.     if ((strchr (imgopt, (int) 'b') != NULL)

  433. 	|| (strchr (imgopt, (int) 'c') != NULL)

  434. 	|| (strchr (imgopt, (int) 't') != NULL)

  435. 	|| (strchr (imgopt, (int) 'd') != NULL)) {

  436.       ch = Calibrate (prow, nrow, CH_OFFSET + SYNC_WIDTH);

  437.       if (ch >= 0) {

  438. 	if (strchr (imgopt, (int) 'b') != NULL) {

  439. 	  sprintf (pngfilename, "%s/%s-%s.png", pngdirname, name, chid[ch]);

  440. 	  ImageOut (pngfilename, chid[ch], prow, nrow, depth,

  441. 		    SPC_WIDTH + CH_WIDTH + TELE_WIDTH,

  442. 		    CH_OFFSET + SYNC_WIDTH);

  443. 	}

  444.       }

  445.       if (ch > 2) {

  446. 	b = 1;

  447. 	Temperature (prow, nrow, ch, CH_OFFSET + SYNC_WIDTH);

  448. 	if (strchr (imgopt, (int) 't') != NULL) {

  449. 	  sprintf (pngfilename, "%s/%s-t.png", pngdirname, name);

  450. 	  ImageOut (pngfilename, "Temperature", prow, nrow, depth,

  451. 		    CH_WIDTH, CH_OFFSET + SYNC_WIDTH + SPC_WIDTH);

  452. 	}

  453.       }

  454.     }

  455. 

  456. /* distribution */

  457.     if (a && b && strchr (imgopt, (int) 'd') != NULL) {

  458.       sprintf (pngfilename, "%s/%s-d.pnm", pngdirname, name);

  459.     }

  460. 

  461. /* color image */

  462.     if (a && b && strchr (imgopt, (int) 'c') != NULL) {

  463.       sprintf (pngfilename, "%s/%s-c.png", pngdirname, name);

  464.       ImageColorOut (pngfilename, prow, nrow);

  465.     }

  466. 

  467.   }

  468.   exit (0);

  469. }