Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Purpose:  Various public (documented) utility functions.
       4             :  *
       5             :  ******************************************************************************
       6             :  * Copyright (c) 2009
       7             :  * PCI Geomatics, 90 Allstate Parkway, Markham, Ontario, Canada.
       8             :  *
       9             :  * SPDX-License-Identifier: MIT
      10             :  ****************************************************************************/
      11             : #include "pcidsk_config.h"
      12             : #include "pcidsk_types.h"
      13             : #include "pcidsk_exception.h"
      14             : #include "core/pcidsk_utils.h"
      15             : #include <cstdlib>
      16             : #include <cstring>
      17             : 
      18             : using namespace PCIDSK;
      19             : 
      20             : /************************************************************************/
      21             : /*                            DataTypeSize()                            */
      22             : /************************************************************************/
      23             : 
      24             : /**
      25             :  * Return size of data type.
      26             :  *
      27             :  * Note that type CHN_BIT exists to represent one bit backed data from
      28             :  * bitmap segments, but because the return of this functions is measured
      29             :  * in bytes, the size of a CHN_BIT pixel cannot be properly returned (one
      30             :  * eighth of a byte), so "1" is returned instead.
      31             :  *
      32             :  * @param chan_type the channel type enumeration value.
      33             :  *
      34             :  * @return the size of the passed data type in bytes, or zero for unknown
      35             :  * values.
      36             :  */
      37             : 
      38        3010 : int PCIDSK::DataTypeSize( eChanType chan_type )
      39             : 
      40             : {
      41        3010 :     switch( chan_type )
      42             :     {
      43        1106 :       case CHN_8U:
      44        1106 :         return 1;
      45         159 :       case CHN_16S:
      46         159 :         return 2;
      47         380 :       case CHN_16U:
      48         380 :         return 2;
      49         111 :       case CHN_32S:
      50         111 :         return 4;
      51         111 :       case CHN_32U:
      52         111 :         return 4;
      53         159 :       case CHN_32R:
      54         159 :         return 4;
      55         111 :       case CHN_64S:
      56         111 :         return 8;
      57         111 :       case CHN_64U:
      58         111 :         return 8;
      59         111 :       case CHN_64R:
      60         111 :         return 8;
      61         111 :       case CHN_C16U:
      62         111 :         return 4;
      63         159 :       case CHN_C16S:
      64         159 :         return 4;
      65         111 :       case CHN_C32U:
      66         111 :         return 8;
      67         111 :       case CHN_C32S:
      68         111 :         return 8;
      69         159 :       case CHN_C32R:
      70         159 :         return 8;
      71           0 :       case CHN_BIT:
      72           0 :         return 1; // not really accurate!
      73           0 :       default:
      74           0 :         return 0;
      75             :     }
      76             : }
      77             : 
      78             : /************************************************************************/
      79             : /*                            DataTypeName()                            */
      80             : /************************************************************************/
      81             : 
      82             : /**
      83             :  * Return name for the data type.
      84             :  *
      85             :  * The returned values are suitable for display to people, and matches
      86             :  * the portion of the name after the underscore (i.e. "8U" for CHN_8U.
      87             :  *
      88             :  * @param chan_type the channel type enumeration value to be translated.
      89             :  *
      90             :  * @return a string representing the data type.
      91             :  */
      92             : 
      93         131 : const char * PCIDSK::DataTypeName( eChanType chan_type )
      94             : 
      95             : {
      96         131 :     switch( chan_type )
      97             :     {
      98          92 :       case CHN_8U:
      99          92 :         return "8U";
     100           5 :       case CHN_16S:
     101           5 :         return "16S";
     102          19 :       case CHN_16U:
     103          19 :         return "16U";
     104           0 :       case CHN_32S:
     105           0 :         return "32S";
     106           0 :       case CHN_32U:
     107           0 :         return "32U";
     108           5 :       case CHN_32R:
     109           5 :         return "32R";
     110           0 :       case CHN_64S:
     111           0 :         return "64S";
     112           0 :       case CHN_64U:
     113           0 :         return "64U";
     114           0 :       case CHN_64R:
     115           0 :         return "64R";
     116           0 :       case CHN_C16U:
     117           0 :         return "C16U";
     118           5 :       case CHN_C16S:
     119           5 :         return "C16S";
     120           0 :       case CHN_C32U:
     121           0 :         return "C32U";
     122           0 :       case CHN_C32S:
     123           0 :         return "C32S";
     124           5 :       case CHN_C32R:
     125           5 :         return "C32R";
     126           0 :       case CHN_BIT:
     127           0 :         return "BIT";
     128           0 :       default:
     129           0 :         return "UNK";
     130             :     }
     131             : }
     132             : 
     133             : /************************************************************************/
     134             : /*                      GetDataTypeFromName()                           */
     135             : /************************************************************************/
     136             : 
     137             : /**
     138             :  * @brief Return the segment type code based on the contents of type_name
     139             :  *
     140             :  * @param pszDataType the type name, as a string
     141             :  *
     142             :  * @return the channel type code
     143             :  */
     144         388 : eChanType PCIDSK::GetDataTypeFromName(const char * pszDataType)
     145             : {
     146         388 :     if (strstr(pszDataType, "8U") != nullptr)
     147         265 :         return CHN_8U;
     148         123 :     if (strstr(pszDataType, "C16U") != nullptr)
     149           0 :         return CHN_C16U;
     150         123 :     if (strstr(pszDataType, "C16S") != nullptr)
     151           9 :         return CHN_C16S;
     152         114 :     if (strstr(pszDataType, "C32U") != nullptr)
     153           0 :         return CHN_C32U;
     154         114 :     if (strstr(pszDataType, "C32S") != nullptr)
     155           0 :         return CHN_C32S;
     156         114 :     if (strstr(pszDataType, "C32R") != nullptr)
     157           9 :         return CHN_C32R;
     158         105 :     if (strstr(pszDataType, "16U") != nullptr)
     159          87 :         return CHN_16U;
     160          18 :     if (strstr(pszDataType, "16S") != nullptr)
     161           9 :         return CHN_16S;
     162           9 :     if (strstr(pszDataType, "32U") != nullptr)
     163           0 :         return CHN_32U;
     164           9 :     if (strstr(pszDataType, "32S") != nullptr)
     165           0 :         return CHN_32S;
     166           9 :     if (strstr(pszDataType, "32R") != nullptr)
     167           9 :         return CHN_32R;
     168           0 :     if (strstr(pszDataType, "64U") != nullptr)
     169           0 :         return CHN_64U;
     170           0 :     if (strstr(pszDataType, "64S") != nullptr)
     171           0 :         return CHN_64S;
     172           0 :     if (strstr(pszDataType, "64R") != nullptr)
     173           0 :         return CHN_64R;
     174           0 :     if (strstr(pszDataType, "BIT") != nullptr)
     175           0 :         return CHN_BIT;
     176             : 
     177           0 :     return CHN_UNKNOWN;
     178             : }
     179             : 
     180             : /************************************************************************/
     181             : /*                       IsDataTypeComplex()                           */
     182             : /************************************************************************/
     183             : 
     184             : /**
     185             :  * @brief Return whether or not the data type is complex
     186             :  *
     187             :  * @param type the type
     188             :  *
     189             :  * @return true if the data type is complex, false otherwise
     190             :  */
     191           0 : bool PCIDSK::IsDataTypeComplex(eChanType type)
     192             : {
     193           0 :     switch(type)
     194             :     {
     195           0 :     case CHN_C32R:
     196             :     case CHN_C32U:
     197             :     case CHN_C32S:
     198             :     case CHN_C16U:
     199             :     case CHN_C16S:
     200           0 :         return true;
     201           0 :     default:
     202           0 :         return false;
     203             :     }
     204             : }
     205             : 
     206             : /************************************************************************/
     207             : /*                          SegmentTypeName()                           */
     208             : /************************************************************************/
     209             : 
     210             : /**
     211             :  * Return name for segment type.
     212             :  *
     213             :  * Returns a short name for the segment type code passed in.  This is normally
     214             :  * the portion of the enumeration name that comes after the underscore - i.e.
     215             :  * "BIT" for SEG_BIT.
     216             :  *
     217             :  * @param type the segment type code.
     218             :  *
     219             :  * @return the string for the segment type.
     220             :  */
     221             : 
     222        4111 : const char * PCIDSK::SegmentTypeName( int type )
     223             : {
     224        4111 :     switch( type )
     225             :     {
     226           0 :       case SEG_BIT:
     227           0 :         return "BIT";
     228        3547 :       case SEG_VEC:
     229        3547 :         return "VEC";
     230           0 :       case SEG_SIG:
     231           0 :         return "SIG";
     232           0 :       case SEG_TEX:
     233           0 :         return "TEX";
     234         238 :       case SEG_GEO:
     235         238 :         return "GEO";
     236           0 :       case SEG_ORB:
     237           0 :         return "ORB";
     238           0 :       case SEG_LUT:
     239           0 :         return "LUT";
     240           4 :       case SEG_PCT:
     241           4 :         return "PCT";
     242           0 :       case SEG_BLUT:
     243           0 :         return "BLUT";
     244           0 :       case SEG_BPCT:
     245           0 :         return "BPCT";
     246           0 :       case SEG_BIN:
     247           0 :         return "BIN";
     248           0 :       case SEG_ARR:
     249           0 :         return "ARR";
     250         322 :       case SEG_SYS:
     251         322 :         return "SYS";
     252           0 :       case SEG_GCPOLD:
     253           0 :         return "GCPOLD";
     254           0 :       case SEG_GCP2:
     255           0 :         return "GCP2";
     256           0 :       default:
     257           0 :         return "UNKNOWN";
     258             :     }
     259             : }