home *** CD-ROM | disk | FTP | other *** search
/ vis-ftp.cs.umass.edu / vis-ftp.cs.umass.edu.tar / vis-ftp.cs.umass.edu / pub / Software / ASCENDER / umass_foa.tar / mdt_NEW / ISRhdrs / TokenStream.cc < prev    next >
C/C++ Source or Header  |  1995-01-11  |  23KB  |  939 lines
  1. /*
  2.  * ------------------------------------------------------------------
  3.  * TokenStream.cc - TokenStream implementation
  4.  * Created by  Bruce Draper
  5.  * ------------------------------------------------------------------
  6.  * Modification History: $Log: TokenStream.cc,v $
  7. // Revision 1.6  1994/11/23  21:02:51  heller
  8. // Add magic number and auto byte swaping code (.isrb files)
  9. //
  10. // Revision 1.5  1994/10/26  16:42:05  heller
  11. // Add code to allow writing BytePlanes as GIF files (greyscale).
  12. //
  13. // Revision 1.4  1994/10/26  14:30:52  heller
  14. // add support to write intensity planes from ColorImage
  15. // tokens when the output format only supports a single
  16. // Plane token (.plane and .im type output streams).
  17. //
  18. // Revision 1.3  1994/10/17  18:07:37  heller
  19. // Added support for writing viff 3-band color images.
  20. //
  21. // Revision 1.2  1994/10/14  19:46:21  heller
  22. // Added support for reading viff 3-band color images.
  23. //
  24.  * ------------------------------------------------------------------
  25.  * Contents:
  26.  * ------------------------------------------------------------------
  27.  *  
  28.  * 
  29.  *            Copyright 1994 University of Massachusetts.
  30.  *                          All rights reserved.
  31.  * 
  32.  *      Permission to copy and modify this software and its documen-
  33.  *      tation only for internal use in your organization is hereby
  34.  *      granted, provided that this notice is retained thereon and
  35.  *      on all copies.  UMASS makes no representations as to the sui-
  36.  *      tability and operability of this software for any purpose.
  37.  *      It is provided "as is" without express or implied warranty.
  38.  * 
  39.  *      UMASS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  40.  *      INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
  41.  *      NESS.  IN NO EVENT SHALL UMASS BE LIABLE FOR ANY SPECIAL,
  42.  *      INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY OTHER DAMAGES WHAT-
  43.  *      SOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
  44.  *      IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  45.  *      ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PER-
  46.  *      FORMANCE OF THIS SOFTWARE.
  47.  * 
  48.  *      No other rights, including, for example, the right to redis-
  49.  *      tribute this software and its documentation or the right to
  50.  *      prepare derivative works, are granted unless specifically
  51.  *      provided in a separate license agreement.
  52.  * 
  53.  *      Copyright 1994, University of Massachusetts. All rights
  54.  *      reserved.
  55.  * 
  56.  * 
  57.  */
  58.  
  59. static char rcsid[] = "$Id: TokenStream.cc,v 1.6 1994/11/23 21:02:51 heller Exp $";
  60.  
  61. #include <TokenStream.h>
  62.  
  63. extern Registry *print_registry;
  64.  
  65. /* File Organization:
  66.  * Part 1: TokenStream code: TokenIStreams and TokenOStreams are top-level
  67.            streams for the user. They read/write any type of token.
  68.  * Part 2: ISRIstream & ISROstream: code for implementing .isra and .isrb file
  69.            formats.
  70.  * Part3: code for reading other formats (.viff, .im, ... )
  71.  */
  72.  
  73. /* Part 1 ****************************************************************/
  74.  
  75. void TokenStream::TokenStreamInit() 
  76. {
  77.   name = NULL;
  78.   state = Closed;
  79.   format = untyped;
  80. }
  81.  
  82. void TokenStream::TokenStreamFree() 
  83. {
  84.   TokenStreamInit();
  85. }
  86.  
  87. int TokenStream::SetFormat(StreamFormat stream_format)
  88. {
  89.   cerr << "Error: use TokenIStream or TokenOStream, not TokenStream.\n";
  90.   exit(-1);
  91.   return(0);    // make the compiler happy
  92. }
  93.  
  94. int TokenStream::openp() 
  95. {
  96.   if (state == Open) return 1;
  97.   else return 0;
  98. }
  99.  
  100. int TokenStream::MatchFormatToFilename(char *filename)
  101. {
  102.   if (NULL == filename) {
  103.     cerr << "Filename is NULL.\n";
  104.     return(-1);
  105.   }
  106.    
  107.   if (NULL != strstr(filename, ".isrb")) {
  108.     SetFormat(isrb);
  109.     return(0);
  110.   }
  111.   if (NULL != strstr(filename, ".isra")) {
  112.     SetFormat(isra);
  113.     return(0);
  114.   }
  115.   if (NULL != strstr(filename, ".plane")) {
  116.     SetFormat(plane);
  117.     return(0);
  118.   }
  119. #ifdef KHOROS
  120.   if (NULL != strstr(filename, ".viff")) {
  121.     SetFormat(viff);
  122.     return(0);
  123.   }
  124.   if (NULL != strstr(filename, ".xv")) {
  125.     SetFormat(viff);
  126.     return(0);
  127.   }
  128. #endif
  129. #ifdef KBV
  130.   if (NULL != strstr(filename, ".im")) {
  131.     SetFormat(im);
  132.     return(0);
  133.   }
  134.   if (NULL != strstr(filename, ".tks")) {
  135.     SetFormat(tks);
  136.     return(0);
  137.   }
  138. #endif
  139.   if (NULL != strstr(filename, ".gif")) {
  140.     SetFormat(gif);
  141.     return(0);
  142.   }
  143. #ifdef TIFFLIB
  144.   if (NULL != strstr(filename, ".tiff")) {
  145.     SetFormat(tiff);
  146.     return(0);
  147.   }
  148.   if (NULL != strstr(filename, ".tif")) {
  149.     SetFormat(tiff);
  150.     return(0);
  151.   }
  152. #endif
  153.   cerr << "Unrecognized file extension.\n";
  154.   return(-1);
  155. }
  156.  
  157. void TokenOStream::open(char *filename)
  158. {
  159.   if (state == Open) {
  160.     cerr << "Warning: Attempt to open already opened TokenOStream.\n";
  161.     return;
  162.   }
  163.  
  164.   name = filename;
  165.   state = Open;
  166.   if (format_stream == NULL) MatchFormatToFilename(filename);
  167.   if (format_stream == NULL) {
  168.     cerr << "Unable to open file.\n";
  169.     exit(-1);
  170.   }
  171.   format_stream->open(filename);
  172. }
  173.  
  174. void TokenOStream::close()
  175. {
  176.   if (state == Closed) {
  177.     cerr << "Warning: Attempt to close already closed TokenOStream.\n";
  178.     return;
  179.   }
  180.  
  181.   state = Closed;
  182.   if (format_stream != NULL) format_stream->close();
  183. }
  184.  
  185. int TokenOStream::SetFormat(StreamFormat stream_format)
  186. {
  187.   /* first, check stream state (should be closed with format == NULL) */
  188.   if (state == Open) {
  189.     cerr << "attempt to reformat stream when file is open! (Close file first.)\n";
  190.     return -1;
  191.   }
  192.   if (format_stream != NULL) delete format_stream;
  193.  
  194.   format = stream_format;
  195.   switch (stream_format) {
  196.   case isra: 
  197.     format_stream = new ISROStream(isra); 
  198.     break;
  199.   case isrb: 
  200.     format_stream = new ISROStream(isrb); 
  201.     break;
  202.   case plane:
  203.     format_stream = new PlaneOStream; 
  204.     break;
  205. #ifdef KHOROS
  206.   case viff:
  207.     format_stream = new ViffOStream; 
  208.     break;
  209. #endif
  210. #ifdef KBV
  211.   case im:
  212.     format_stream = new ImOStream;
  213.     break;
  214.   case tks:
  215.     format_stream = new TksOStream;
  216.     break;
  217. #endif
  218.   case gif:
  219.     format_stream = new GifOStream;
  220.     break;
  221. #ifdef TIFFLIB
  222.   case tiff:
  223.     format_stream = new TiffOStream;
  224.     break;
  225. #endif
  226.   default:
  227.     cerr << "Unknown or unimplemented file type.\n";
  228.     format = untyped;
  229.     return -1;
  230.   }
  231.  
  232.   return 0;
  233. }
  234.  
  235. TokenOStream::TokenOStream()
  236. {
  237.   TokenStreamInit();
  238.   format_stream = NULL;
  239. }
  240.  
  241. TokenOStream::TokenOStream(StreamFormat type)
  242. {
  243.   TokenStreamInit();
  244.   format_stream = NULL;
  245.   SetFormat(type);
  246. }
  247.  
  248. TokenOStream::TokenOStream(char *filename)
  249. {
  250.   TokenStreamInit();
  251.   format_stream = NULL;
  252.   MatchFormatToFilename(filename);
  253. }
  254.  
  255. TokenOStream::~TokenOStream()
  256. {
  257.   if (format_stream != NULL) delete format_stream;
  258.   TokenStreamFree();
  259. }
  260.  
  261. TokenOStream& operator << (TokenOStream& tos, Token& tok)
  262. {
  263.   if (tos.state == Closed) {
  264.     if (tos.name == NULL) {
  265.       cerr << "attempt to write to unopened & unnamed file.\n";
  266.       exit(-1);
  267.     }
  268.     else tos.open(tos.name);
  269.   }
  270.  
  271.   tos.format_stream->write_token(tok);
  272.   return tos;
  273. }
  274.  
  275. TokenOStream& operator << (TokenOStream& tos, Token* tok)
  276. {
  277.   tos << *tok;
  278.   return tos;
  279. }
  280.  
  281. int operator ! (TokenOStream& tos)
  282. {
  283.   if (tos.format_stream == NULL) return 0;
  284.   else return !(*tos.format_stream);
  285. }
  286.  
  287. void TokenIStream::open(char *filename)
  288. {
  289.   if (state == Open) {
  290.     cerr << "Warning: Attempt to open already open TokenIStream.\n";
  291.     return;
  292.   }
  293.  
  294.   name = filename;
  295.   state = Open;
  296.   if (format_stream == NULL) MatchFormatToFilename(filename);
  297.   if (format_stream == NULL) {
  298.     cerr << "Unable to open file.\n";
  299.     exit(-1);
  300.   }
  301.   format_stream->open(filename);
  302. }
  303.  
  304. void TokenIStream::close()
  305. {
  306.   if (state == Closed) {
  307.     cerr << "Warning: Attempt to close already closed TokenIStream.\n";
  308.     return;
  309.   }
  310.  
  311.   state = Closed;
  312.   if (format_stream != NULL) format_stream->close();
  313. }
  314.  
  315. int TokenIStream::SetFormat(StreamFormat stream_format)
  316. {
  317.   /* first, check stream state (should be closed with format == NULL) */
  318.   if (state == Open) {
  319.     cerr << "attempt to reformat stream when file is open! (Close file first.)\n";
  320.     return -1;
  321.   }
  322.   if (format_stream != NULL) delete format_stream;
  323.  
  324.   format = stream_format;
  325.   switch (stream_format) {
  326.   case isra: 
  327.     format_stream = new ISRIStream(isra); break;
  328.   case isrb: 
  329.     format_stream = new ISRIStream(isrb); break;
  330.   case plane:
  331.     format_stream = new PlaneIStream; break;
  332. #ifdef KHOROS
  333.   case viff:
  334.     format_stream = new ViffIStream; break;
  335. #endif
  336. #ifdef KBV
  337.   case im:
  338.     format_stream = new ImIStream; break;
  339.   case tks:
  340.     format_stream = new TksIStream;
  341.     break;
  342. #endif
  343.   case gif:
  344.     format_stream = new GifIStream;
  345.     break;
  346. #ifdef TIFFLIB
  347.   case tiff:
  348.     format_stream = new TiffIStream;
  349.     break;
  350. #endif
  351.   default:
  352.     cerr << "Unknown or unimplemented file type.\n";
  353.     format = untyped;
  354.     return -1;
  355.   }
  356.  
  357.   return 0;
  358. }
  359.  
  360. TokenIStream::TokenIStream()
  361. {
  362.   TokenStreamInit();
  363.   format_stream = NULL;
  364. }
  365.  
  366. TokenIStream::TokenIStream(StreamFormat type)
  367. {
  368.   TokenStreamInit();
  369.   format_stream = NULL;
  370.   SetFormat(type);
  371. }
  372.  
  373. TokenIStream::TokenIStream(char *filename)
  374. {
  375.   TokenStreamInit();
  376.   format_stream = NULL;
  377.   MatchFormatToFilename(filename);
  378. }
  379.  
  380. TokenIStream::~TokenIStream()
  381. {
  382.   if (format_stream != NULL) delete format_stream;
  383.   TokenStreamFree();
  384. }
  385.  
  386. Token *TokenIStream::read_token_ptr()
  387. {
  388.   if (state == Closed) {
  389.     if (name == NULL) {
  390.       cerr << "attempt to write to unopened & unnamed file.\n";
  391.       exit(-1);
  392.     }
  393.     else open(name);
  394.   }
  395.  
  396.   return format_stream->read_token_ptr();
  397. }
  398.  
  399. TokenIStream& operator >> (TokenIStream& tos, Token& tok)
  400. {
  401.   if (tos.state == Closed) {
  402.     if (tos.name == NULL) {
  403.       cerr << "attempt to write to unopened & unnamed file.\n";
  404.       exit(-1);
  405.     }
  406.     else tos.open(tos.name);
  407.   }
  408.  
  409.   tos.format_stream->read_token(tok);
  410.   return tos;
  411. }
  412.  
  413. int operator ! (TokenIStream& tis)
  414. {
  415.   if (tis.format_stream == NULL) return 0;
  416.   else return !(*tis.format_stream);
  417. }
  418.  
  419. /** Part 2 ***********************************************************/
  420.  
  421. ISROStream::ISROStream(StreamFormat format) 
  422. {
  423.   if (format == isrb) isr_stream = new Isrostream(BINARY, ISR);
  424.   else if (format == isra) isr_stream = new Isrostream(ASCII, ISR);
  425.   else {
  426.     cerr << "ISROStream initialized with illegal StreaFormat.\n";
  427.     exit(-1);
  428.   }
  429.  
  430.   if (isr_stream == NULL) {
  431.     cerr << "Unable to allocate Isrostream structure.\n";
  432.     exit(-1);
  433.   }
  434. }
  435.  
  436. ISROStream::~ISROStream() 
  437. {
  438.   delete isr_stream;
  439. }
  440.  
  441. void ISROStream::open(char *filename)
  442. {
  443.   isr_stream->open(filename, ios::out);
  444. }
  445.  
  446. void ISROStream::close()
  447. {
  448.   isr_stream->close();
  449. }
  450.  
  451. void ISROStream::write_token(Token& tok)
  452. {
  453.   /* << sets up the table to guard against infinite loops
  454.      when printing. token_array_ptr is a pointer to an array
  455.      of token pointers. When a token is "demanded" by trace
  456.      (calling for some action) it is added to the token array,
  457.      (if it wasn't there already) and the demand ptr is advanced. 
  458.      When a token is printed, the print ptr is advanced. Printing
  459.      continues until the print ptr catches the demand ptr, meaning
  460.      that every referenced token has been printed.  */
  461.  
  462.   Registry to_print(tok.token_count);
  463.   TypeDirectory* type_table_ptr = system_type_table();
  464.   Token *current_token;   
  465.   int index;     
  466.   Isrostream os = *isr_stream;
  467.  
  468.   /* Set up registry and register the first token */
  469.   assert(print_registry == NULL);
  470.   print_registry = &to_print;
  471.   to_print.Register(&tok);
  472.  
  473.   /* deactivate type table, to see which types are actually being printed */
  474.   type_table_ptr->deactivate();
  475.  
  476.   /* recursively trace data tree from first token */
  477.   while (0 <= (index = to_print.next())) {
  478.     current_token = to_print.translate(index);
  479.     type_table_ptr->activate(current_token->type_index());
  480.     current_token->trace();
  481.   }
  482.  
  483.   /* print file header */
  484.   os.write_magic_header();
  485.   os << to_print.count() << " tokens ";
  486.   os << type_table_ptr->active_entries() << " tokentypes ";
  487.   os << type_table_ptr->max_active_entry() << " maximum tokentype index\n\n";
  488.   if (!os) {
  489.     cerr << "Unable to write to output stream\n";
  490.     exit(-1);
  491.     }
  492.   type_table_ptr->print_active_entries(os);
  493.  
  494.   /* recursively print traced tokens */
  495.   to_print.reset();
  496.   while (0 <= (index = to_print.next())) {
  497.     current_token = to_print.translate(index);
  498.     write_token_number_and_type(os, current_token, index);
  499.     os << "\n";
  500.     current_token->output(os);
  501.     os << "\n";
  502.     if (!os) {
  503.       cerr << "Error writing in token print function\n";
  504.       exit(-1);
  505.     }
  506.   }
  507.  
  508.   /* Destroy static registry (destructor will execute when
  509.      to_print leaves the lexical scope). */
  510.   print_registry = NULL;
  511. }
  512.  
  513.  
  514. ISRIStream::ISRIStream(StreamFormat format) 
  515. {
  516.   if (format == isrb) isr_stream = new Isristream(BINARY, ISR);
  517.   else if (format == isra) isr_stream = new Isristream(ASCII, ISR);
  518.   else {
  519.     cerr << "ISRIStream initialized with illegal StreamFormat.\n";
  520.     exit(-1);
  521.   }
  522.  
  523.   if (isr_stream == NULL) {
  524.     cerr << "Unable to allocate Isristream structure.\n";
  525.     exit(-1);
  526.   }
  527. }
  528.  
  529. ISRIStream::~ISRIStream() 
  530. {
  531.   delete isr_stream;
  532. }
  533.  
  534. void ISRIStream::open(char *filename)
  535. {
  536.   isr_stream->open(filename, ios::in);
  537. }
  538.  
  539. void ISRIStream::close()
  540. {
  541.   isr_stream->close();
  542. }
  543.  
  544. /* This dummy function allows the real reading function below 1) to take
  545.    a token to fill as an optional argument and 2) to be used by the PlaneIStream
  546.    class as well. (PlaneIStream is a subclass that will redefine read_token_ptr). */
  547. Token* ISRIStream::read_token_ptr()
  548. {
  549.   return internal_read_token_ptr();
  550. }
  551.  
  552. Token* ISRIStream::internal_read_token_ptr (Token* preallocated/* = NULL*/)
  553. {
  554.   Isristream is = *isr_stream;
  555.   int token_count = -1, tokentype_count = -1, max_tokentype_entry = -1, i;
  556.   Token* new_token;
  557.  
  558.   if (!is) {
  559.     cerr << "File unopened or unable to read from file\n";
  560.     exit(-1);
  561.   }
  562.   
  563.   /* open file and read how many tokens are in it. */
  564.   is.read_magic_header();
  565.   is >> token_count >> "tokens";
  566.   is >> tokentype_count >> "tokentypes";
  567.   is >> max_tokentype_entry >> "maximum tokentype index";
  568.   max_tokentype_entry++;
  569.   if ((!is) || (0 >= token_count) || (0 >= tokentype_count)
  570.       || (tokentype_count > max_tokentype_entry)) 
  571.     {
  572.       cerr << "Unable to read header; probably wrong file type\n";
  573.       exit(-1);
  574.     }
  575.   
  576.   /* allocate and read stream-specific tokentype table */
  577.   is.read_tokentype_table(tokentype_count, max_tokentype_entry);
  578.   
  579.   /* allocate appropriate size registry */
  580.   print_registry = new Registry(token_count);
  581.  
  582.   /* iteratively read all tokens in file */
  583.   for (i=0; i < token_count; i++) {
  584.     new_token = read_token_file_ptr(is, preallocated);
  585.     preallocated = NULL;
  586.  
  587.     /* if new_token is NULL, an error has occurred, since NULL
  588.        pointers should only appear as feature values, not as tokens
  589.        to be read in their own right */
  590.     if (new_token == NULL) {
  591.       cerr << "file includes definition of NULL token\n";
  592.       exit(-1);
  593.     }
  594.     
  595.     /* expand to include possible alt_inputs in the future, for
  596.        translating token types. */
  597.     new_token->input(is);
  598.     
  599.     if (!is) {
  600.       cerr << "Error reading token (in user-defined read function)\n";
  601.       exit(-1);
  602.     }
  603.   }
  604.   
  605.   /* deallocate registry and return pointer to first token */
  606.   new_token = print_registry->translate(0);
  607.   free(print_registry);
  608.   print_registry = NULL;
  609.   return new_token;
  610. }
  611.  
  612. void ISRIStream::read_token (Token& tok)
  613. {
  614.   internal_read_token_ptr(&tok);
  615. }
  616.  
  617. /**********/
  618.  
  619.  
  620. PlaneOStream::~PlaneOStream() 
  621. {
  622.   delete isr_stream;
  623. }
  624.  
  625. void PlaneOStream::write_token(Token& tok)
  626. {
  627.   if (strcmp(tok.name(), "ColorImage") == 0)
  628.   {
  629.     ColorImage *ci = (ColorImage*) &tok;
  630.     ci->intensity()->output(*isr_stream);
  631.     if (!(*isr_stream)) {
  632.       cerr << "Error writing token (in user-defined output function)\n";
  633.       exit(-1);
  634.     } else return;
  635.   } else if (NULL == strstr(tok.name(), "Plane")) {
  636.     cerr << "Plane Files can only store Plane tokens, not " 
  637.       << tok.name() << " tokens.\n";
  638.     cerr << "Nothing will be written to file or stream.\n";
  639.     return;
  640.   }
  641.   
  642.   tok.output(*isr_stream);
  643.   if (!(*isr_stream)) {
  644.     cerr << "Error writing token (in user-defined output function)\n";
  645.     exit(-1);
  646.   }
  647. }
  648.  
  649. PlaneIStream::~PlaneIStream() 
  650. {
  651.   delete isr_stream;
  652. }
  653.  
  654. Token *PlaneIStream::read_token_ptr()
  655. {
  656.   return (Token *)read_llvs_plane(*isr_stream);
  657. }
  658.  
  659. void PlaneIStream::read_token(Token& tok)
  660. {
  661.   Token *temp;;
  662.   Isristream is = *isr_stream;
  663.  
  664.   if (NULL == strstr(tok.name(), "Plane")) {
  665.     cerr << "Plane Files can only store Plane tokens, not " 
  666.       << tok.name() << " tokens.\n";
  667.     cerr << "Nothing will be read from file or stream.\n";
  668.     return;
  669.   }
  670.  
  671.   temp = read_llvs_plane(is);
  672.   if (!is) cerr << "Error in plane reading function.\n";
  673.   else copy_plane_header((Plane *)temp, (Plane *)&tok);
  674. }
  675.  
  676. #ifdef KHOROS
  677. void ViffOStream::open(char *fname)
  678. {
  679.   filename = fname;
  680. }
  681.  
  682. void ViffOStream::write_token(Token& tok)
  683. {
  684.   if (strcmp(tok.name(), "ColorImage") == 0) {
  685.     if (!writecolorimage(filename, (ColorImage*)&tok)) {
  686.     cerr << "Viff Files can only store ColorImage tokens with active "
  687.     << "RGB or HSV planes.\n";
  688.     }
  689.   } else if (NULL == strstr(tok.name(), "Plane")) {
  690.     cerr << "Viff Files can only store Plane or ColorImage tokens, not " 
  691.       << tok.name() << " tokens.\n";
  692.     cerr << "Nothing will be written to file or stream.\n";
  693.     return;
  694.   } else writeplaneimage(filename, (Plane *)&tok);
  695. }
  696.  
  697. void ViffIStream::open(char *fname)
  698. {
  699.   if (0 != access(fname, R_OK)) {
  700.     cerr << "Unable to find Viff file " << fname << " for reading. \n";
  701.     exit(-1);
  702.   }
  703.  
  704.   filename = fname;
  705. }
  706.  
  707. Token *ViffIStream::read_token_ptr()
  708. {
  709.   struct xvimage *image = readimage(filename);
  710.   Token *result;
  711.  
  712.   if (image == NULL)
  713.   {
  714.     cerr << "Cannot read image file: " << filename << "\n";
  715.     return NULL;
  716.   }
  717.   else if (image->num_of_images == 1 && image->num_data_bands == 1 &&
  718.       image->location_type == VFF_LOC_IMPLICIT)
  719.   {
  720.     result = (Token *)viff2llvs(image);
  721.   } else if (image->num_of_images == 1 && image->num_data_bands == 3 &&
  722.          image->location_type == VFF_LOC_IMPLICIT &&
  723.          (image->color_space_model == VFF_CM_ntscRGB ||
  724.           image->color_space_model == VFF_CM_cieRGB || 
  725.           image->color_space_model == VFF_CM_genericRGB || 
  726.           image->color_space_model == VFF_CM_HSV))
  727.   {
  728.     result = (Token *)viff2ColorImage(image);
  729.   } else
  730.   {
  731.     cerr << "Don't know how to deal with this viff file: " << filename << "\n";
  732.     result = NULL;
  733.   }
  734.   freeimage(image);
  735.   return result;
  736. }
  737.  
  738. void ViffIStream::read_token(Token& tok)
  739. {
  740.   Token *temp;
  741.  
  742.   temp = read_token_ptr();
  743.   if (temp == NULL)
  744.   {
  745.     return; 
  746.   } else if (strstr(tok.name(), "Plane") != NULL &&
  747.          strstr(temp->name(), "Plane") != NULL)
  748.   {
  749.     copy_plane_header((Plane *)temp, (Plane *)&tok);
  750.   } else if (strcmp(tok.name(),"ColorImage") == 0 &&
  751.            (strcmp(temp->name(),"ColorImage") == 0))
  752.   {
  753.     copy_ColorImage_header((ColorImage*)temp,(ColorImage*)&tok);
  754.   } else
  755.   {
  756.     cerr << "Viff Files can only store Plane or ColorImage tokens, not " 
  757.       << tok.name() << " tokens.\n";
  758.     cerr << "Nothing will be read from file or stream.\n";
  759.   }
  760. }
  761. #endif
  762. #ifdef KBV
  763. void ImOStream::open(char *fname)
  764. {
  765.   filename = fname;
  766. }
  767.  
  768. void ImOStream::write_token(Token& tok)
  769. {
  770.   if (strcmp(tok.name(), "ColorImage") == 0)
  771.   {
  772.     ColorImage *ci = (ColorImage*) &tok;
  773.     writekbvimage(filename, (Plane *)(ci->intensity()));
  774.     return;
  775.   } else if (NULL == strstr(tok.name(), "Plane")) {
  776.     cerr << "Im Files can only store Plane tokens, not " 
  777.       << tok.name() << " tokens.\n";
  778.     cerr << "Nothing will be written to file or stream.\n";
  779.     return;
  780.   }
  781.   
  782.   writekbvimage(filename, (Plane *)&tok);
  783. }
  784.  
  785. void ImIStream::open(char *fname)
  786. {
  787.   if (0 != access(fname, R_OK)) {
  788.     cerr << "Unable to find Im file " << fname << " for reading. \n";
  789.     exit(-1);
  790.   }
  791.  
  792.   filename = fname;
  793. }
  794.  
  795. Token *ImIStream::read_token_ptr()
  796. {
  797.   return readkbvplane(filename);
  798. }
  799.  
  800. void ImIStream::read_token(Token& tok)
  801. {
  802.   Token *temp;
  803.  
  804.   if (NULL == strstr(tok.name(), "Plane")) {
  805.     cerr << "Im Files can only store Plane tokens, not " 
  806.       << tok.name() << " tokens.\n";
  807.     cerr << "Nothing will be read from file or stream.\n";
  808.     return;
  809.   }
  810.   
  811.   temp = read_token_ptr();
  812.   copy_plane_header((Plane *)temp, (Plane *)&tok);
  813. }
  814. #endif
  815.  
  816. void GifIStream::open(char *fname)
  817. {
  818.   if (0 != access(fname, R_OK)) {
  819.     cerr << "Unable to find Gif file " << fname << " for reading. \n";
  820.     exit(-1);
  821.   }
  822.  
  823.   filename = fname;
  824. }
  825.  
  826. Token *GifIStream::read_token_ptr()
  827. {
  828.   return (Token *)GIF2ColorImage(filename);
  829. }
  830.  
  831. void GifIStream::read_token(Token& tok)
  832. {
  833.   ColorImage *temp;
  834.   if (0 != strcmp(tok.name(), "ColorImage")) {
  835.     cerr << "Gif Files can only store ColorImage tokens, not "
  836.          << tok.name() << " tokens.\n";
  837.     cerr << "Nothing will be read from file or stream.\n";
  838.     return;
  839.   }
  840.  
  841.   temp = (ColorImage*) read_token_ptr();
  842.   ((ColorImage*)&tok)->SetRedGreenBlue(temp->red(),temp->green(),temp->blue());
  843.   delete temp;
  844. }
  845.  
  846. void GifOStream::open(char *fname)
  847. {
  848.   filename = fname;
  849. }
  850.  
  851. void GifOStream::write_token(Token& tok)
  852. {
  853.   if (0 == strcmp(tok.name(), "BytePlane")) {
  854.     ColorImage *ci = new ColorImage((BytePlane*)&tok,
  855.                     (BytePlane*)&tok,
  856.                     (BytePlane*)&tok);
  857.     writeGifFile(filename, ci);
  858.     delete ci;
  859.   }
  860.   else if (0 != strcmp(tok.name(), "ColorImage")) {
  861.     cerr << "Gif Files can only store ColorImage tokens, not " 
  862.       << tok.name() << " tokens.\n";
  863.     cerr << "Nothing will be written to file or stream.\n";
  864.   } else writeGifFile(filename, (ColorImage *)&tok);
  865. }
  866.  
  867. #ifdef TIFFLIB
  868. void TiffIStream::open(char *fname)
  869. {
  870.   if (0 != access(fname, R_OK)) {
  871.     cerr << "Unable to find Tiff file " << fname << " for reading. \n";
  872.     exit(-1);
  873.   }
  874.  
  875.   filename = fname;
  876. }
  877.  
  878. Token *TiffIStream::read_token_ptr()
  879. {
  880.   return ReadTiffFile(filename);
  881. }
  882.  
  883. void TiffIStream::read_token(Token& tok)
  884. {
  885.   Token *temp;
  886.   if (strcmp(tok.name(),"BytePlane") != 0 &&
  887.       strcmp(tok.name(),"ColorImage") != 0)
  888.   {
  889.     cerr << "Tiff Files can only store ColorImage or BytePlane tokens, not "
  890.          << tok.name() << " tokens.\n";
  891.     cerr << "Nothing will be read from file or stream.\n";
  892.     delete temp;
  893.     return;
  894.   }
  895.  
  896.   temp = read_token_ptr();
  897.   if (strcmp(temp->name(),tok.name()) == 0)
  898.   {
  899.       if (strcmp(temp->name(),"BytePlane") == 0)
  900.         copy_plane_header((Plane*)&tok,(Plane*)temp);
  901.     else
  902.     {
  903.         ColorImage *ci = (ColorImage*) temp;
  904.         ((ColorImage*)&tok)->SetRedGreenBlue(ci->red(),ci->green(),ci->blue());
  905.         delete temp;
  906.     }
  907.   }
  908.   else
  909.   {
  910.       cerr << "Tiff File is " << temp->name() << " and token is " << tok.name()
  911.            << "\nNot the same, cannot convert\n";
  912.       delete temp;
  913.   }
  914. }
  915.  
  916. void TiffOStream::open(char *fname)
  917. {
  918.   filename = fname;
  919. }
  920.  
  921. void TiffOStream::write_token(Token& tok)
  922. {
  923.   if (strcmp(tok.name(),"BytePlane") == 0)
  924.   {
  925.       writeTiffFile(filename, (BytePlane*) &tok);
  926.   } else if (strcmp(tok.name(),"ColorImage") == 0)
  927.   {
  928.       writeTiffFile(filename, (ColorImage*) &tok);
  929.   } else
  930.   {
  931.       cerr << "Tiff Files can only store ColorImage or BytePlane tokens, not "
  932.            << tok.name() << " tokens.\n";
  933.       cerr << "Nothing will be written to the file or stream.\n";
  934.   }
  935. }
  936.  
  937.  
  938. #endif
  939.