API tools faq
paste
Guest User

DM Script to import TIFF files from microscopes

a guest
Apr 6th, 2021
393
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 17.30 KB | None | 0 0
raw download clone embed print report
  1. // Some constants (See TIFF Format)
  2. number kLittleEndianTIFF    = 0x4949
  3. number kBigEndianTIFF       = 0x4D4D
  4. number kMagicIDNumberTIFF   = 42
  5.  
  6. number FALSE = 0
  7. number TRUE = 1
  8.  
  9. Interface I_ImportTiffWithTags
  10. {
  11.     // Aux. method to simplify single value read from stream
  12.     number ReadValueOfType( object self, string type );
  13.    
  14.     // Aux. method to strip multiple pre- and post- string occurances from a string
  15.     string ClipText( object self, string input, string leadIn, string leadOut, number doMultiple );
  16.     string ClipTextWhiteSpaces( object self, string input );
  17.  
  18.     // Aux. method to convert ASCII text of specific format into a TagStructure
  19.     TagGroup CreateTagsFromString( object self, string input, string entrySep, string keyToValueSep, string GroupLeadIn, string GroupLeadOut );
  20.     TagGroup CreateTagsFromString_FEI_Default( object self, string input );
  21.     TagGroup CreateTagsFromString_ZEISS_Default( object self, string input );
  22.  
  23.     // Get all TIFF tags from file in path as tagGroup 
  24.     TagGroup GetTIFFTagsAsTG( object self, string path, number doTextFields, number doSingleValues, number includedSkipped );  
  25.     TagGroup GetTIFFTagsAsTG( object self, string path, number includedSkipped );   // doTextField = true, doSingleValues = true
  26.     TagGroup GetTIFFTagsAsTG( object self, string path );                           // doTextField = true, doSingleValues = true, includedSkipped = false
  27.    
  28.     // Get all ASCII TIFF tags as single string
  29.     String  GetTIFFAscii( object self, string path, number splitSeparateTags );
  30.     String  GetTIFFAscii( object self, string path); // splitSeparateTags = true
  31.    
  32.     // Import Image and append TIFF tags as TagGroup "TIFF Tags" to image
  33.     image OpenTIFFWithTags( object self, string path );
  34.    
  35.     // Import TIFF Image stored by FEI SEMs, import info from ASCII in image, calibrate if possible
  36.     image OpenFEI_TIFF( object self, string path, number withTiffTags );
  37.     image OpenFEI_TIFF( object self, string path );
  38.    
  39.     // Import TIFF Image stored by ZEISS SEMs, import info from ASCII in image, calibrate if possible
  40.     image OpenZEISS_TIFF( object self, string path, number withTiffTags );
  41.     image OpenZEISS_TIFF( object self, string path);
  42.    
  43.     // Aux. to find calibration from the tags, format specific
  44.     number GetCalibrationFromTags_FEI( object self, tagGroup FEItgs, number &sx, number &ox, string &ux, number &sy, number &oy, string &uy );
  45.     number GetCalibrationFromTags_ZEISS( object self, tagGroup ZEISStags, number &sx, number &ox, string &ux, number &sy, number &oy, string &uy );
  46.    
  47. }
  48.  
  49. Class CImportTIFFWithTags
  50. {
  51.     object fStream
  52.     number byteOrder
  53.     number verbose
  54.     number kMaxTextShow
  55.    
  56.     CImportTIFFWithTags( object self )
  57.     {
  58.         verbose = FALSE
  59.         kMaxTextShow = 20
  60.     }
  61.    
  62.     number ReadValueOfType( object self, string type )
  63.     {
  64.         if ( !fStream.ScriptObjectIsValid() ) Throw( "Invalid file stream." )
  65.         number val = 0
  66.         TagGroup tg = NewTagGroup()
  67.         if ( type == "bool" )
  68.         {
  69.             tg.TagGroupSetTagAsBoolean( type, 0 )
  70.             tg.TagGroupReadTagDataFromStream( type, fstream, byteOrder )
  71.             tg.TagGroupGetTagAsBoolean( type, val )
  72.         }
  73.         else if ( type == "uint8" )
  74.         {
  75.             string str = fStream.StreamReadAsText(0,1)
  76.             val = asc(str)
  77.         }
  78.         else if ( type == "uint16" )
  79.         {
  80.             tg.TagGroupSetTagAsUInt16( type, 0 )
  81.             tg.TagGroupReadTagDataFromStream( type, fstream, byteOrder )
  82.             tg.TagGroupGetTagAsUInt16( type, val )
  83.         }
  84.         else if ( type == "uint32" )
  85.         {
  86.             tg.TagGroupSetTagAsUInt32( type, 0 )
  87.             tg.TagGroupReadTagDataFromStream( type, fstream, byteOrder )
  88.             tg.TagGroupGetTagAsUInt32( type, val )
  89.         }
  90.         else if ( type == "float" )
  91.         {
  92.             tg.TagGroupSetTagAsFloat( type, 0 )
  93.             tg.TagGroupReadTagDataFromStream( type, fstream, byteOrder )
  94.             tg.TagGroupGetTagAsFloat( type, val )
  95.         }
  96.         else if ( type == "double" )
  97.         {
  98.             tg.TagGroupSetTagAsDouble( type, 0 )
  99.             tg.TagGroupReadTagDataFromStream( type, fstream, byteOrder )
  100.             tg.TagGroupGetTagAsDouble( type, val )
  101.         }
  102.         else Throw("Invalid read-type:"+type)
  103.         return val
  104.     }
  105.    
  106.    
  107.     string ClipText( object self, string input, string leadIn, string leadOut, number doMultiple )
  108.     {
  109.         string work = input
  110.         if ( len(leadIn) <= len(work) )
  111.         {
  112.             while ( leadIn == left(work,len(leadIn)) )
  113.             {
  114.                 work = right( work, len(work) - len(leadIn) )
  115.                 if ( !doMultiple ) break
  116.                 if ( len(work) < len(leadin) ) break
  117.             }
  118.         }
  119.         if ( len(leadOut) <= len(work) )
  120.         {
  121.             while ( leadOut == right(work,len(leadout)) )
  122.             {
  123.                 work = left( work, len(work) - len(leadOut) )
  124.                 if ( !doMultiple ) break
  125.                 if ( len(leadOut) <= len(work) ) break
  126.             }
  127.         }
  128.         return work
  129.     }
  130.    
  131.     string ClipTextWhiteSpaces( object self, string input )
  132.     {
  133.         return self.ClipText( input, " ", " ", TRUE );
  134.     }
  135.    
  136.     TagGroup CreateTagsFromString( object self, string input, string entrySep, string keyToValueSep, string GroupLeadIn, string GroupLeadOut )
  137.     {
  138.         TagGroup tg = NewTagGroup()
  139.         number bCheckGroup = ( len(GroupLeadIn) && len(GroupLeadOut) )  // true if groupLeads are specified
  140.         string work = input
  141.         string groupName = ""
  142.         if ( "" == entrySep )
  143.             entrySep = "\n"
  144.        
  145.         number pos = find( work, entrySep )
  146.         number skipped = 0
  147.         while( -1 != pos )
  148.         {
  149.             //OKDialog("work:"+work)
  150.             //OKDialog("Entry:"+len(entrySep) )
  151.             string entry = left( work, pos )
  152.             work = right( work, len(work) - len(entry) - len(entrySep) + 1)
  153.             number sep     = find( entry, keyToValueSep )
  154.            
  155.             if( -1 < sep )                                                 
  156.             {
  157.                 // Entry matches format "KEY=VALUE" with '=' being the defined entrySep
  158.                 string key  = left( entry, sep )
  159.                 string value= right( entry, len(entry) - sep - len(keyToValueSep) )
  160.                 // Truncate trailing white spaces
  161.                 key   = self.ClipTextWhiteSpaces(key)
  162.                 value = self.ClipTextWhiteSpaces(value)
  163.                
  164.                 string tagPath = groupName + ( "" == groupName ? "" : ":" ) + key
  165.                 tg.TagGroupSetTagAsString( tagPath, value )
  166.             }
  167.             else if ( bCheckGroup )
  168.             {
  169.                 // Entry does not match format "KEY=VALUE", check if it is a groupname
  170.                 number leadIn  = find( entry, GroupLeadIn )
  171.                 number leadOut = find( entry, GroupLeadOut )
  172.                 if ( ( -1 < leadIn ) && ( -1 < leadOut ) && ( leadIn < leadOut ) ) // Is it a new group? "[GROUPNAME]"
  173.                 {
  174.                     groupName = mid( entry, leadIn + len(GroupLeadIn), leadOut - leadIn - len(GroupLeadOut) )
  175.                 }  
  176.                 else
  177.                     skipped++
  178.             }
  179.             else
  180.             {
  181.                 skipped++  
  182.             }
  183.             // Find next entry
  184.             pos = find( work, entrySep )       
  185.         }
  186.         if ( 0 != len(work) )
  187.             skipped++
  188.            
  189.         if ( verbose )
  190.         {
  191.             if ( skipped )
  192.                 Result( "\nText To Tag skipped " + skipped + " lines.\n" )
  193.         }
  194.    
  195.         return tg
  196.     }
  197.    
  198.     TagGroup CreateTagsFromString_FEI_Default( object self, string input )
  199.     {
  200.         return self.CreateTagsFromString( input, "\n" , "=", "[", "]" )
  201.     }
  202.    
  203.     TagGroup CreateTagsFromString_ZEISS_Default( object self, string input )
  204.     {
  205.         return self.CreateTagsFromString( input, "\n" , "=", "", "" )
  206.     }
  207.    
  208.    
  209.     TagGroup GetTIFFTagsAsTG( object self, string path, number doTextFields, number doSingleValues, number includedSkipped )
  210.     {
  211.         if ( !DoesFileExist( path ) ) Throw( "File not found.\n"+path)
  212.        
  213.         // Open Stream
  214.         number fileID = OpenFileForReading( path )
  215.         fStream = NewStreamFromFileReference(fileID,1)
  216.        
  217.         // Find Byte Order
  218.         number val
  219.         byteOrder = 0
  220.         val = self.ReadValueOfType( "uint16" )
  221.         byteOrder = ( kLittleEndianTIFF == val  ) ? 2 : ( kBigEndianTIFF == val ? 1 : 0 )
  222.        
  223.         // Verify TIFF image
  224.         val = self.ReadValueOfType( "uint16" )
  225.         if ( val != kMagicIDNumberTIFF ) Throw( "Not a valid TIFF image" )
  226.        
  227.         // Find first directory start
  228.         number offset = self.ReadValueOfType( "uint32" )
  229.        
  230.         // Browse all directories
  231.         number nIFD = 0
  232.         TagGroup AllTiffTagsTGlist = NewTagList()
  233.         TagGroup TiffTGs
  234.         while( 0 != offset )
  235.         {
  236.             // Set to start of directory and read it in
  237.             nIFD++
  238.             TiffTGs = NewTagGroup()
  239.             if ( verbose )  Result( "Reading IFD #" + nIFD + " at \t" + offset )
  240.                                
  241.             fStream.StreamSetPos( 0, offset )  
  242.             number nEntries = self.ReadValueOfType( "uint16" )
  243.             for ( number e=0; e<nEntries; e++ )
  244.             {
  245.                 number tag        = self.ReadValueOfType( "uint16" )
  246.                 string tagStr     = "ID("+tag+")"
  247.                 number typ        = self.ReadValueOfType( "uint16" )
  248.                 number count      = self.ReadValueOfType( "uint32" )
  249.                 number dataOffset = self.ReadValueOfType( "uint32" )
  250.                 if ( verbose )
  251.                     Result( "\n DirEntry # "+Format(e,"%3.0f") + ": TiffIDTag: " + tag + "]ttyp: " + typ + "\tcount: " + count )
  252.  
  253.                 // Read only, if it is either a single value or a string                               
  254.                 if ( ( doTextFields ) && ( 2 == typ )  )// ASCII
  255.                 {
  256.                     number currentPos = fStream.StreamGetPos()
  257.                     fStream.StreamSetPos( 0, dataOffset )
  258.                     string textField = fStream.StreamReadAsText( 0, count )
  259.                     fStream.StreamSetPos( 0, currentPos )
  260.                     if ( verbose ) Result( "\t value: " + left( textField, min(len(textField), kMaxTextShow ) ) )
  261.                     TiffTGs.TagGroupSetTagAsString( tagStr, textField )    
  262.                 }  
  263.                 else if ( ( doSingleValues ) && ( 1 == count )  ) // Single Value.
  264.                 {
  265.                     // Note that the 'dataOffset'-4-bytes are already the value for data fitting in 4-bytes!
  266.                     // Otherwise, it specifies the staring offset for the value
  267.                    
  268.                     if ( 1 == typ )         // uInt8
  269.                     {
  270.                         TiffTGs.TagGroupSetTagAsShort( tagStr, dataOffset )
  271.                         if ( verbose )  Result("\t value:" + dataOffset )
  272.                     }
  273.                     else if ( 3 == typ )    // uInt16
  274.                     {
  275.                         TiffTGs.TagGroupSetTagAsUInt16( tagStr, dataOffset )   
  276.                         if ( verbose )  Result("\t value:" + dataOffset )
  277.                     }
  278.                     else if ( 4 == typ )    // uInt32
  279.                     {
  280.                         TiffTGs.TagGroupSetTagAsUInt32( tagStr, dataOffset )   
  281.                         if ( verbose )  Result("\t value:" + dataOffset )
  282.                     }
  283.                     else if ( 5 == typ )    // uInt32 / uInt32 (rational)
  284.                     {
  285.                         number currentPos = fStream.StreamGetPos()
  286.                         number val1 = self.ReadValueOfType( "uint32" )
  287.                         number val2 = self.ReadValueOfType( "uint32" )
  288.                         TiffTGs.TagGroupSetTagAsLongPoint( tagStr, val1, val2 )
  289.                         fStream.StreamSetPos( 0, currentPos )
  290.                         if ( verbose )  Result("\t value:" + val1 + "/" + val2 )
  291.                     }
  292.                     else if ( 11 == typ )   // float
  293.                     {
  294.                         TiffTGs.TagGroupSetTagAsFloat( tagStr, dataOffset )                
  295.                         if ( verbose )  Result("\t value:" + dataOffset )
  296.                     }
  297.                     else if ( 12 == typ )   // double
  298.                     {
  299.                         number currentPos = fStream.StreamGetPos()
  300.                         number val = self.ReadValueOfType( "double" )
  301.                         TiffTGs.TagGroupSetTagAsDouble( tagStr, val )
  302.                         fStream.StreamSetPos( 0, currentPos )
  303.                         if ( verbose )  Result("\t value:" + val )
  304.                     }
  305.                     else if ( includedSkipped )
  306.                     {
  307.                         if ( verbose )  Result("\t value: SKIPPED DATA TYPE" )
  308.                         TiffTGs.TagGroupSetTagAsString( tagStr, "Not imported, TagType (TIFF "+typ+")" )
  309.                     }              
  310.                 }
  311.                 else if ( includedSkipped )
  312.                 {
  313.                     // Multiple value entries
  314.                     if ( verbose )  Result("\t value: Multiple values. Arrays are not read." )
  315.                     TiffTGs.TagGroupSetTagAsString( tagStr, "Not imported, TagType (TIFF "+typ+") "+count+" values" )
  316.                 }
  317.             }
  318.             // Read next directory offset.
  319.             // This is 0000 for the last directory according to spec
  320.             offset = self.ReadValueOfType( "uint32" )
  321.             AllTiffTagsTGlist.TagGroupAddTagGroupAtEnd(TiffTGs)
  322.         }
  323.        
  324.         // Return list if entries or just one group if there is one directory only
  325.         if ( 1 < nIFD )
  326.             return AllTiffTagsTGlist
  327.         else
  328.             return TiffTGs
  329.     }
  330.     TagGroup GetTIFFTagsAsTG( object self, string path, number includedSkipped )
  331.     {
  332.         return self.GetTIFFTagsAsTG( path, TRUE, TRUE, includedSkipped )
  333.     }
  334.     TagGroup GetTIFFTagsAsTG( object self, string path )
  335.     {
  336.         return self.GetTIFFTagsAsTG( path, TRUE, TRUE, FALSE )
  337.     }  
  338.    
  339.     String  GetTIFFAscii( object self, string path, number splitSeparateTags )
  340.     {
  341.         String allText
  342.         TagGroup tgs = self.GetTIFFTagsAsTG(path, TRUE, FALSE, FALSE )
  343.         number nTags = tgs.TagGroupCountTags()
  344.         for ( number n=0; n<nTags; n++ )
  345.         {
  346.             string label = tgs.TagGroupGetTagLabel(n)
  347.             if ( splitSeparateTags )
  348.             {
  349.                 if ( 1<nTags )
  350.                     allText += (n?"\n":"")+"TIFF Tag " + label + ":\n"
  351.             }
  352.             string text
  353.             if ( tgs.TagGroupGetTagAsString( label, text ) )
  354.                 allText += text + "\n"         
  355.         }
  356.        
  357.         return allText
  358.     }
  359.    
  360.     String  GetTIFFAscii( object self, string path)
  361.     {
  362.         return self.GetTIFFAscii( path, true )
  363.     }
  364.    
  365.     image OpenTIFFWithTags( object self, string path )
  366.     {
  367.         image Imported := OpenImage( path )
  368.         TagGroup TIFFTags = self.GetTIFFTagsAsTG(path, TRUE, TRUE, TRUE)
  369.         Imported.ImageGetTagGroup().TagGroupSetTagAsTagGroup( "TIFF Tags", TIFFTags )
  370.         return Imported
  371.     }
  372.    
  373.     image OpenFEI_TIFF( object self, string path, number withTiffTags )
  374.     {
  375.         image Imported := OpenImage( path )
  376.         if ( withTiffTags )
  377.         {
  378.             TagGroup TIFFTags = self.GetTIFFTagsAsTG(path, TRUE, TRUE, FALSE )
  379.             Imported.ImageGetTagGroup().TagGroupSetTagAsTagGroup( "TIFF Tags", TIFFTags )
  380.         }
  381.         string ASCIITags = self.GetTIFFAscii(path)
  382.         TagGroup FEITags = self.CreateTagsFromString_FEI_Default( ASCIITags )
  383.         Imported.ImageGetTagGroup().TagGroupSetTagAsTagGroup( "Info", FEITags )
  384.         number sx, sy, ox, oy
  385.         string ux, uy
  386.         if ( self.GetCalibrationFromTags_FEI(FEITags, sx, ox, ux, sy, oy, uy ) )
  387.         {
  388.             Imported.ImageSetDimensionCalibration(0,ox,sx,ux,0)
  389.             Imported.ImageSetDimensionCalibration(1,oy,sy,uy,0)
  390.         }
  391.         else
  392.         {
  393.             if ( verbose )
  394.                 Result( "\n FEI calibration not found. Image remains uncalibrated." )
  395.         }
  396.         return Imported
  397.     }
  398.    
  399.     number GetCalibrationFromTags_FEI( object self, tagGroup FEItags, number &sx, number &ox, string &ux, number &sy, number &oy, string &uy )
  400.     {
  401.         if ( !FEItags.TagGroupIsValid() ) return FALSE
  402.         number foundSomething = FALSE
  403.         ox=0
  404.         oy=0
  405.         sx=1
  406.         sy=1
  407.         ux=""
  408.         uy=""
  409.         number value
  410.         if ( FEITags.TagGroupGetTagAsNumber( "Scan:PixelWidth", value ) )
  411.         {
  412.             foundSomething = TRUE
  413.             // [value] is in [m], scale to nm or um
  414.             if ( value < 1e-6 )
  415.             {
  416.                 if ( value < 1e-9 )
  417.                 {
  418.                     ux = "nm"
  419.                     sx =  value * 1e9
  420.                 }
  421.                 else
  422.                 {
  423.                     ux = "µm"
  424.                     sx =  value * 1e6
  425.                 }
  426.             }
  427.         }
  428.         if ( FEITags.TagGroupGetTagAsNumber( "Scan:PixelHeight", value ) )
  429.         {
  430.             foundSomething = TRUE
  431.             // [value] is in [m], scale to nm or um
  432.             if ( value < 1e-6 )
  433.             {
  434.                 if ( value < 1e-9 )
  435.                 {
  436.                     uy = "nm"
  437.                     sy =  value * 1e9
  438.                 }
  439.                 else
  440.                 {
  441.                     uy = "µm"
  442.                     sy =  value * 1e6
  443.                 }
  444.             }
  445.         }
  446.         return foundSomething
  447.     }
  448.    
  449.    
  450.     image OpenFEI_TIFF( object self, string path )
  451.     {
  452.         return self.OpenFEI_TIFF( path, FALSE )
  453.     }
  454.    
  455.     image OpenZEISS_TIFF( object self, string path, number withTiffTags )
  456.     {
  457.         image Imported := OpenImage( path )
  458.         if ( withTiffTags )
  459.         {
  460.             TagGroup TIFFTags = self.GetTIFFTagsAsTG(path, TRUE, TRUE, FALSE )
  461.             Imported.ImageGetTagGroup().TagGroupSetTagAsTagGroup( "TIFF Tags", TIFFTags )
  462.         }
  463.         string ASCIITags = self.GetTIFFAscii(path)
  464.         TagGroup ZEISSTags = self.CreateTagsFromString_ZEISS_Default( ASCIITags )
  465.         Imported.ImageGetTagGroup().TagGroupSetTagAsTagGroup( "Info", ZEISSTags  )
  466.         number sx, sy, ox, oy
  467.         string ux, uy
  468.         if ( self.GetCalibrationFromTags_ZEISS(ZEISSTags, sx, ox, ux, sy, oy, uy ) )
  469.         {
  470.             // "scale" gives full FOV!
  471.             if ( sx!= 1)
  472.                 Imported.ImageSetDimensionCalibration(0,ox,sx/Imported.ImageGetDimensionSize(0),ux,0)
  473.             if ( sy!= 1)
  474.                 Imported.ImageSetDimensionCalibration(1,oy,sy/Imported.ImageGetDimensionSize(1),uy,0)
  475.         }
  476.         else
  477.         {
  478.             if ( verbose )
  479.                 Result( "\n ZEISS calibration not found. Image remains uncalibrated." )
  480.         }
  481.         return Imported
  482.     }
  483.    
  484.     image OpenZEISS_TIFF( object self, string path )
  485.     {
  486.         return self.OpenZEISS_TIFF( path, FALSE )
  487.     }
  488.    
  489.     number GetCalibrationFromTags_ZEISS( object self, tagGroup ZEISStags, number &sx, number &ox, string &ux, number &sy, number &oy, string &uy )
  490.     {
  491.         if ( !ZEISStags.TagGroupIsValid() ) return FALSE
  492.         number foundSomething = FALSE
  493.         ox=0
  494.         oy=0
  495.         sx=1
  496.         sy=1
  497.         ux=""
  498.         uy=""
  499.         string value
  500.         if ( ZEISStags.TagGroupGetTagAsString( "Width", value ) )
  501.         {
  502.             number pos = find( value, " " ) // separate unit!
  503.             if ( -1 < pos )
  504.             {
  505.                 sx = val( left(value,pos) )     // FOV width not scale!!
  506.                 ux  = right( value, len(value)-pos-1 )
  507.                 foundSomething = TRUE
  508.             }
  509.         }
  510.         if ( ZEISStags.TagGroupGetTagAsString( "Height", value ) )
  511.         {
  512.             number pos = find( value, " " ) // separate unit!
  513.             if ( -1 < pos )
  514.             {
  515.                 sy = val( left(value,pos) )     // FOV width not scale!!
  516.                 uy  = right( value, len(value)-pos-1 )
  517.                 foundSomething = TRUE
  518.             }
  519.         }
  520.         return foundSomething  
  521.     }
  522. }
  523.  
  524. ///////////////////
  525. // CALL EXAMPLES //
  526. ///////////////////
  527.  
  528. number option = 1
  529. string msg
  530. msg += "IMPORT TIFF - EXAMPLE\n"
  531. msg += "Select what you want to do:\n"
  532. msg += "(1)\t Import and calibrate FEI TIFF.\n"
  533. msg += "(2)\t Import and calibrate ZEISS TIFF.\n"
  534. msg += "(3)\t Show text content of TIFF.\n"
  535. msg += "(4)\t Show TIFF tags in browser.\n"
  536.  
  537. while ( 4<option || 1>option )
  538. {
  539.     if ( !GetNumber(msg,option,option)) exit(0)
  540. }
  541.  
  542. string path = GetApplicationDirectory("open_save",0)
  543. if (!OpenDialog(NULL,"Select TIFF file",path, path)) exit(0)
  544.  
  545. if ( 1 == option  )
  546.     Alloc(CImportTIFFWithTags).OpenFEI_TIFF(path).ShowImage()
  547. else if ( 2 == option  )
  548.     Alloc(CImportTIFFWithTags).OpenZEISS_TIFF(path).ShowImage()
  549. else if ( 3 == option )
  550.     Result( "\n\n\n\n_____________________________\n" +Alloc(CImportTIFFWithTags).GetTIFFAscii(path) )
  551. else if ( 4 == option )
  552.     Alloc(CImportTIFFWithTags).GetTIFFTagsAsTG(path,true,true,true).TagGroupOpenBrowserWindow(path,0)
  553.  
  554.  
  555.  
  556.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!