KDIS/DataTypes/GridAxisIrregular.cpp

   1 /*********************************************************************
   2 Copyright 2013 Karl Jones
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions are met:
   7
   8 1. Redistributions of source code must retain the above copyright notice, this
   9    list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright notice,
  11    this list of conditions and the following disclaimer in the documentation
  12    and/or other materials provided with the distribution.
  13
  14 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  15 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  18 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  21 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  23 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24
  25 For Further Information Please Contact me at
  26 Karljj1@yahoo.com
  27 http://p.sf.net/kdis/UserGuide
  28 *********************************************************************/
  29
  30 #include "./GridAxisIrregular.h"
  31
  32 using namespace std;
  33 using namespace KDIS;
  34 using namespace DATA_TYPE;
  35
  36 //////////////////////////////////////////////////////////////////////////
  37 // protected:
  38 //////////////////////////////////////////////////////////////////////////
  39
  40 void GridAxisIrregular::calculatePadding()
  41 {
  42     // Calculate padding needed to be on a 64 bit boundary.
  43     m_vui16Padding.clear();
  44     KUINT8 NumPadding = m_ui16NumPoints % 4;
  45
  46     // Add the padding
  47     KUINT16 Padding = 0;
  48     for( KUINT8 i = 0; i < NumPadding; ++i )
  49     {
  50         m_vui16Padding.push_back( Padding );
  51     }
  52 }
  53
  54 //////////////////////////////////////////////////////////////////////////
  55 // Public:
  56 //////////////////////////////////////////////////////////////////////////
  57
  58 GridAxisIrregular::GridAxisIrregular() :
  59     m_f64CoordScaleXi( 0 ),
  60     m_f64CoordOffsetXi( 0 )
  61 {
  62 }
  63
  64 //////////////////////////////////////////////////////////////////////////
  65
  66 GridAxisIrregular::GridAxisIrregular( KDataStream & stream )
  67 {
  68     Decode( stream );
  69 }
  70
  71 //////////////////////////////////////////////////////////////////////////
  72
  73 GridAxisIrregular::GridAxisIrregular( KFLOAT64 InitialXi, KFLOAT64 FinalXi, KUINT16 PointsXi, KUINT8 InterleafFactor,
  74                                       KUINT8 AxisType, KDataStream & stream ) :
  75     GridAxisRegular( InitialXi, FinalXi, PointsXi, InterleafFactor, AxisType, stream )
  76 {
  77     stream >> m_f64CoordScaleXi
  78            >> m_f64CoordOffsetXi;
  79
  80     KUINT16 ui16TmpVal = 0;
  81     for( KUINT16 i = 0; i < m_ui16NumPoints; ++i )
  82     {
  83         stream >> ui16TmpVal;
  84         m_vXiValues.push_back( ui16TmpVal );
  85     }
  86
  87     // Calculate the padding that needs to be extracted. 64 bit boundary
  88     KUINT8 NumPadding = m_ui16NumPoints % 4;
  89     for( KUINT8 i = 0; i < NumPadding; ++i )
  90     {
  91         stream >> ui16TmpVal;
  92         m_vui16Padding.push_back( ui16TmpVal );
  93     }
  94 }
  95
  96 //////////////////////////////////////////////////////////////////////////
  97
  98 GridAxisIrregular::GridAxisIrregular( KFLOAT64 InitialXi, KFLOAT64 FinalXi, KUINT16 PointsXi, KUINT8 InterleafFactor,
  99                                       KUINT8 AxisType, KUINT16 InitialIndexXi, KFLOAT64 CoordinateScaleXi,
 100                                       KFLOAT64 CoordinateOffsetXi, const vector<KUINT16> & XiValues ) :
 101     GridAxisRegular( InitialXi, FinalXi, PointsXi, InterleafFactor, AxisType, XiValues.size(), InitialIndexXi ),
 102     m_f64CoordScaleXi( CoordinateScaleXi ),
 103     m_f64CoordOffsetXi( CoordinateOffsetXi ),
 104     m_vXiValues( XiValues )
 105 {
 106     calculatePadding();
 107 }
 108
 109 //////////////////////////////////////////////////////////////////////////
 110
 111 GridAxisIrregular::~GridAxisIrregular()
 112 {
 113 }
 114
 115 //////////////////////////////////////////////////////////////////////////
 116
 117 void GridAxisIrregular::SetCoordinateScaleXi( KFLOAT64 Xi )
 118 {
 119     m_f64CoordScaleXi = Xi;
 120 }
 121
 122 //////////////////////////////////////////////////////////////////////////
 123
 124 KFLOAT64 GridAxisIrregular::GetCoordinateScaleXi() const
 125 {
 126     return m_f64CoordScaleXi;
 127 }
 128
 129 //////////////////////////////////////////////////////////////////////////
 130
 131 void GridAxisIrregular::SetCoordinateOffsetXi( KFLOAT64 Xi )
 132 {
 133     m_f64CoordOffsetXi = Xi;
 134 }
 135
 136 //////////////////////////////////////////////////////////////////////////
 137
 138 KFLOAT64 GridAxisIrregular::GetCoordinateOffsetXi() const
 139 {
 140     return m_f64CoordOffsetXi;
 141 }
 142
 143 //////////////////////////////////////////////////////////////////////////
 144
 145 void GridAxisIrregular::AddXiValue( KUINT16 Xi )
 146 {
 147     m_vXiValues.push_back( Xi );
 148     m_ui16NumPoints = m_vXiValues.size();
 149     calculatePadding();
 150 }
 151
 152 //////////////////////////////////////////////////////////////////////////
 153
 154 void GridAxisIrregular::SetXiValues( const std::vector<KUINT16> & Xi )
 155 {
 156     m_vXiValues = Xi;
 157     m_ui16NumPoints = m_vXiValues.size();
 158     calculatePadding();
 159 }
 160
 161 //////////////////////////////////////////////////////////////////////////
 162
 163 const std::vector<KUINT16> & GridAxisIrregular::GetXiValues() const
 164 {
 165     return m_vXiValues;
 166 }
 167
 168 //////////////////////////////////////////////////////////////////////////
 169
 170 void GridAxisIrregular::ClearXiValues()
 171 {
 172     m_vXiValues.clear();
 173     m_ui16NumPoints = 0;
 174     calculatePadding();
 175 }
 176
 177 //////////////////////////////////////////////////////////////////////////
 178
 179 KBOOL GridAxisIrregular::IsGridRegular() const
 180 {
 181     return false;
 182 }
 183
 184 //////////////////////////////////////////////////////////////////////////
 185
 186 KUINT16 GridAxisIrregular::GetLength()
 187 {
 188     KUINT16 ui16Length = GRID_AXIS_IRREGULAR;
 189     ui16Length += m_vXiValues.size() * 2;
 190     ui16Length += m_vui16Padding.size() * 2;
 191     return ui16Length;
 192 }
 193
 194 //////////////////////////////////////////////////////////////////////////
 195
 196 KString GridAxisIrregular::GetAsString() const
 197 {
 198     KStringStream ss;
 199
 200     ss << "Grid Axis Irregular:"
 201        << "\n\tDomain Initial Xi:    " << m_f64DomainInitialXi
 202        << "\n\tDomain Final Xi:      " << m_f64DomainFinalXi
 203        << "\n\tDomain Points Xi:     " << m_ui16DomainPointsXi
 204        << "\n\tInterleaf Factor:     " << ( KUINT16 )m_ui8InterleafFactor
 205        << "\n\tAxis Type:            " << ( KUINT16 )m_ui8AxisType
 206        << "\n\tNumber Of Points:     " << m_ui16NumPoints
 207        << "\n\tInitial Index:        " << m_ui16InitialIndex
 208        << "\n\tCoordinate Scale Xi:  " << m_f64CoordScaleXi
 209        << "\n\tCoordinate Offset Xi: " << m_f64CoordOffsetXi
 210        << "\n\tXi Values:";
 211
 212     vector<KUINT16>::const_iterator citr = m_vXiValues.begin();
 213     vector<KUINT16>::const_iterator citrEnd = m_vXiValues.end();
 214
 215     for( ; citr != citrEnd; ++citr )
 216     {
 217         ss << "\n\t" << *citr;
 218     }
 219
 220     ss << "\n";
 221
 222     return ss.str();
 223 }
 224
 225 //////////////////////////////////////////////////////////////////////////
 226
 227 void GridAxisIrregular::Decode( KDataStream & stream )
 228 {
 229     if( stream.GetBufferSize() < GRID_AXIS_IRREGULAR )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
 230
 231     m_vXiValues.clear();
 232     m_vui16Padding.clear();
 233
 234     GridAxisRegular::Decode( stream );
 235
 236     stream >> m_f64CoordScaleXi
 237            >> m_f64CoordOffsetXi;
 238
 239     KUINT16 ui16TmpVal = 0;
 240     for( KUINT16 i = 0; i < m_ui16NumPoints; ++i )
 241     {
 242         stream >> ui16TmpVal;
 243         m_vXiValues.push_back( ui16TmpVal );
 244     }
 245
 246     // Calculate the padding that needs to be extracted. 64 bit boundary
 247     KUINT8 NumPadding = m_ui16NumPoints % 4;
 248     for( KUINT8 i = 0; i < NumPadding; ++i )
 249     {
 250         stream >> ui16TmpVal;
 251         m_vui16Padding.push_back( ui16TmpVal );
 252     }
 253 }
 254
 255 //////////////////////////////////////////////////////////////////////////
 256
 257 KDataStream GridAxisIrregular::Encode() const
 258 {
 259     KDataStream stream;
 260
 261     GridAxisIrregular::Encode( stream );
 262
 263     return stream;
 264 }
 265
 266 //////////////////////////////////////////////////////////////////////////
 267
 268 void GridAxisIrregular::Encode( KDataStream & stream ) const
 269 {
 270     GridAxisRegular::Encode( stream );
 271
 272     stream << m_f64CoordScaleXi
 273            << m_f64CoordOffsetXi;
 274
 275     vector<KUINT16>::const_iterator citr = m_vXiValues.begin();
 276     vector<KUINT16>::const_iterator citrEnd = m_vXiValues.end();
 277
 278     for( ; citr != citrEnd; ++citr )
 279     {
 280         stream << *citr;
 281     }
 282
 283     // Padding
 284     citr = m_vui16Padding.begin();
 285     citrEnd = m_vui16Padding.end();
 286
 287     for( ; citr != citrEnd; ++citr )
 288     {
 289         stream << *citr;
 290     }
 291 }
 292
 293 //////////////////////////////////////////////////////////////////////////
 294
 295 KBOOL GridAxisIrregular::operator == ( const GridAxisIrregular & Value ) const
 296 {
 297     if( GridAxisRegular::operator != ( Value ) )          return false;
 298     if( m_f64CoordScaleXi   != Value.m_f64CoordScaleXi )  return false;
 299     if( m_f64CoordOffsetXi  != Value.m_f64CoordOffsetXi ) return false;
 300     if( m_vXiValues         != Value.m_vXiValues )        return false;
 301     return true;
 302 }
 303
 304 //////////////////////////////////////////////////////////////////////////
 305
 306 KBOOL GridAxisIrregular::operator != ( const GridAxisIrregular & Value ) const
 307 {
 308     return !( *this == Value );
 309 }
 310
 311 //////////////////////////////////////////////////////////////////////////
 312