hms
/
aptdec
espelhamento de https://github.com/Xerbo/aptdec
1
0
Fork 0
Código Issues 0 Versões 7 Wiki Atividade
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
44 Commits
2 Branches
3.0 MiB
 
 
 
 
 
Tag: a8ada67af5
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de a8ada67af5
${ noResults }
aptdec/main.c

480 linhas
13 KiB
Original Anotar Histórico 

  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. #ifdef WIN32

  120.   pngfile = fopen (filename, "wb");

  121. #else

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

  123. #endif

  124.   if (pngfile == NULL) {

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

  126.     return (1);

  127.   }

  128.   png_init_io (png_ptr, pngfile);

  129.   png_write_info (png_ptr, info_ptr);

  130. 

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

  132.     float *pixelv;

  133.     png_byte pixel[2 * IMG_WIDTH];

  134.     int i;

  135. 

  136.     pixelv = prow[n];

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

  138.       float pv;

  139. 

  140.       pv = pixelv[i + offset];

  141.       switch (depth) {

  142.       case 8:

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

  144. 	break;

  145. #ifndef WIN32

  146.       case 16:

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

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

  149. 	break;

  150. #endif

  151.       }

  152.     }

  153.     png_write_row (png_ptr, pixel);

  154.   }

  155.   png_write_end (png_ptr, info_ptr);

  156.   fclose (pngfile);

  157.   printf ("Done\n");

  158.   png_destroy_write_struct (&png_ptr, &info_ptr);

  159.   return (0);

  160. }

  161. 

  162. int

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

  164. {

  165.   FILE *pngfile;

  166.   png_infop info_ptr;

  167.   png_structp png_ptr;

  168.   int n;

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

  170.   float pv[CH_WIDTH];

  171.   float pt[CH_WIDTH];

  172. 

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

  174.   extern void dres(

  175. 		float av, float at, float bv, float bt,

  176.   		float cv, float ct, float dv, float dt,

  177. 		float *v , float *t);

  178. 

  179. /* init png lib */

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

  181.   if (!png_ptr) {

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

  183.     return (1);

  184.   }

  185. 

  186.   info_ptr = png_create_info_struct (png_ptr);

  187.   if (!info_ptr) {

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

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

  190.     return (1);

  191.   }

  192. 

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

  194. 		8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,

  195. 		PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

  196. 

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

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

  199. 

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

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

  202. 

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

  204.   fflush (stdout);

  205. #ifdef WIN32

  206.   pngfile = fopen (filename, "wb");

  207. #else

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

  209. #endif

  210.   if (pngfile == NULL) {

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

  212.     return (1);

  213.   }

  214.   png_init_io (png_ptr, pngfile);

  215.   png_write_info (png_ptr, info_ptr);

  216. 

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

  218. 

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

  220.     png_color pixa[2*CH_WIDTH];

  221.     png_color pixb[2*CH_WIDTH];

  222.     int i;

  223. 

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

  225. 

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

  227.       float av,bv,cv,dv;

  228.       float at,bt,ct,dt;

  229.       float pvc,ptc; 

  230.       float v,t; 

  231.       float r, g, b;

  232.     

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

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

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

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

  237.       if(n!=0) {

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

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

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

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

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

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

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

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

  246.       } else  {

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

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

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

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

  251.       }

  252. 

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

  254. 

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

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

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

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

  259. 

  260.       pvc=v;ptc=t;

  261. 

  262.       if(n!=0) {

  263.       av = pv[i];

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

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

  266.       dv = pvc;

  267.       at = pt[i];

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

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

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

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

  272.       dt = ptc;

  273. 

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

  275. 

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

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

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

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

  280.       } 

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

  282. 

  283.       if (i!=0) {

  284. 

  285.       if (n!=0) {

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

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

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

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

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

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

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

  293.       }

  294. 

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

  296.       bv = pv[i-1];

  297.       cv = pvc;

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

  299.       if(n!=0) {

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

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

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

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

  304.       } else {

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

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

  307.       }

  308.       bt = pt[i-1];

  309.       ct = ptc;

  310.       

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

  312. 

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

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

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

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

  317.       }

  318. 

  319.     }

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

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

  322. 

  323.   }

  324.   png_write_end (png_ptr, info_ptr);

  325.   fclose (pngfile);

  326.   printf ("Done\n");

  327.   png_destroy_write_struct (&png_ptr, &info_ptr);

  328.   return (0);

  329. }

  330. 

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

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

  333. extern void readfconf (char *file);

  334. extern int optind, opterr;

  335. extern char *optarg;

  336. int satnum = 1;

  337. 

  338. static void

  339. usage (void)

  340. {

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

  342.   fprintf (stderr,

  343. 	   "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");

  344. }

  345. 

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

  347. {

  348.   char pngfilename[1024];

  349.   char name[1024];

  350.   char pngdirname[1024] = "";

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

  352.   float *prow[3000];

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

  354.   int depth = 8;

  355.   int n, nrow;

  356.   int ch;

  357.   int c;

  358. 

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

  360. 

  361.   opterr = 0;

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

  363.     switch (c) {

  364.     case 'd':

  365.       strcpy (pngdirname, optarg);

  366.       break;

  367.     case 'c':

  368.       readfconf (optarg);

  369.       break;

  370.     case 'i':

  371.       strcpy (imgopt, optarg);

  372.       break;

  373.     case 'p':

  374.       depth = 16;

  375.       break;

  376.     case 's':

  377.       satnum = atoi (optarg);

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

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

  380. 	exit (1);

  381.       }

  382.       break;

  383.     default:

  384.       usage ();

  385.     }

  386.   }

  387. 

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

  389.     prow[nrow] = NULL;

  390. 

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

  392.     int a = 0, b = 0;

  393. 

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

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

  396.     strtok (name, ".");

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

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

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

  400.     }

  401. 

  402. /* open snd input */

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

  404.       exit (1);

  405. 

  406. /* main loop */

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

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

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

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

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

  412. 	break;

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

  414.       fflush (stdout);

  415.     }

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

  417.     sf_close (inwav);

  418. 

  419. /* raw image */

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

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

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

  423.     }

  424. 

  425. /* Channel A */

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

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

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

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

  430.       if (ch >= 0) {

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

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

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

  434. 		    SPC_WIDTH + CH_WIDTH + TELE_WIDTH, SYNC_WIDTH);

  435. 	}

  436.       }

  437.       if (ch < 2)

  438. 	a = 1;

  439.     }

  440. 

  441. /* Channel B */

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

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

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

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

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

  447.       if (ch >= 0) {

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

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

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

  451. 		    SPC_WIDTH + CH_WIDTH + TELE_WIDTH,

  452. 		    CH_OFFSET + SYNC_WIDTH);

  453. 	}

  454.       }

  455.       if (ch > 2) {

  456. 	b = 1;

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

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

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

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

  461. 		    CH_WIDTH, CH_OFFSET + SYNC_WIDTH + SPC_WIDTH);

  462. 	}

  463.       }

  464.     }

  465. 

  466. /* distribution */

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

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

  469.     }

  470. 

  471. /* color image */

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

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

  474.       ImageColorOut (pngfilename, prow, nrow);

  475.     }

  476. 

  477.   }

  478.   exit (0);

  479. }