src/HLRAlgo/HLRAlgo.cxx

   1 // Created on: 1995-09-12
   2 // Created by: Christophe MARION
   3 // Copyright (c) 1995-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17
  18 #include <HLRAlgo.hxx>
  19
  20 static const Standard_Real cosu0 = cos(0.*M_PI/14.);
  21 static const Standard_Real sinu0 = sin(0.*M_PI/14.);
  22 static const Standard_Real cosu1 = cos(1.*M_PI/14.);
  23 static const Standard_Real sinu1 = sin(1.*M_PI/14.);
  24 static const Standard_Real cosu2 = cos(2.*M_PI/14.);
  25 static const Standard_Real sinu2 = sin(2.*M_PI/14.);
  26 static const Standard_Real cosu3 = cos(3.*M_PI/14.);
  27 static const Standard_Real sinu3 = sin(3.*M_PI/14.);
  28 static const Standard_Real cosu4 = cos(4.*M_PI/14.);
  29 static const Standard_Real sinu4 = sin(4.*M_PI/14.);
  30 static const Standard_Real cosu5 = cos(5.*M_PI/14.);
  31 static const Standard_Real sinu5 = sin(5.*M_PI/14.);
  32 static const Standard_Real cosu6 = cos(6.*M_PI/14.);
  33 static const Standard_Real sinu6 = sin(6.*M_PI/14.);
  34
  35 //=======================================================================
  36 //function : UpdateMinMax
  37 //purpose  :
  38 //=======================================================================
  39
  40 void HLRAlgo::UpdateMinMax (const Standard_Real x,
  41                             const Standard_Real y,
  42                             const Standard_Real z,
  43                             Standard_Real Min[16],
  44                             Standard_Real Max[16])
  45 {
  46   Standard_Real d[16];
  47   d[ 0] = cosu0 * x + sinu0 * y;
  48   d[ 1] = sinu0 * x - cosu0 * y;
  49   d[ 2] = cosu1 * x + sinu1 * y;
  50   d[ 3] = sinu1 * x - cosu1 * y;
  51   d[ 4] = cosu2 * x + sinu2 * y;
  52   d[ 5] = sinu2 * x - cosu2 * y;
  53   d[ 6] = cosu3 * x + sinu3 * y;
  54   d[ 7] = sinu3 * x - cosu3 * y;
  55   d[ 8] = cosu4 * x + sinu4 * y;
  56   d[ 9] = sinu4 * x - cosu4 * y;
  57   d[10] = cosu5 * x + sinu5 * y;
  58   d[11] = sinu5 * x - cosu5 * y;
  59   d[12] = cosu6 * x + sinu6 * y;
  60   d[13] = sinu6 * x - cosu6 * y;
  61   d[14] = z;
  62   d[15] = z;
  63
  64   for (Standard_Integer i = 0; i < 16; ++i)
  65   {
  66     if (Min[i] > d[i])
  67     {
  68       Min[i] = d[i];
  69     }
  70     if (Max[i] < d[i])
  71     {
  72       Max[i] = d[i];
  73     }
  74   }
  75 }
  76
  77 //=======================================================================
  78 //function : EnlargeMinMax
  79 //purpose  :
  80 //=======================================================================
  81
  82 void HLRAlgo::EnlargeMinMax (const Standard_Real tol,
  83                              Standard_Real Min[16],
  84                              Standard_Real Max[16])
  85 {
  86   Standard_Integer i = 0;
  87   while (i < 16)
  88   {
  89     Min[i] -= tol;
  90     Max[i] += tol;
  91     i++;
  92   }
  93 }
  94
  95 //=======================================================================
  96 //function :InitMinMax
  97 //purpose  :
  98 //=======================================================================
  99
 100 void HLRAlgo::InitMinMax (const Standard_Real Big,
 101                           Standard_Real Min[16],
 102                           Standard_Real Max[16])
 103 {
 104   Standard_Integer i = 0;
 105   while (i < 16)
 106   {
 107     Min[i] =  Big;
 108     Max[i] = -Big;
 109     i++;
 110   }
 111 }
 112
 113 //=======================================================================
 114 //function : EncodeMinMax
 115 //purpose  :
 116 //=======================================================================
 117
 118 void HLRAlgo::EncodeMinMax (HLRAlgo_EdgesBlock::MinMaxIndices& Min,
 119                             HLRAlgo_EdgesBlock::MinMaxIndices& Max,
 120                             HLRAlgo_EdgesBlock::MinMaxIndices& MM)
 121 {
 122   MM.Min[0] =  Min.Min[1] & 0x00007fff;
 123   MM.Max[0] =  Max.Min[1] & 0x00007fff;
 124   MM.Min[0] += (Min.Min[0] & 0x00007fff) << 16;
 125   MM.Max[0] += (Max.Min[0] & 0x00007fff) <<16;
 126   MM.Min[1] =  Min.Min[3] & 0x00007fff;
 127   MM.Max[1] =  Max.Min[3] & 0x00007fff;
 128   MM.Min[1] += (Min.Min[2] & 0x00007fff) << 16;
 129   MM.Max[1] += (Max.Min[2] & 0x00007fff) << 16;
 130   MM.Min[2] =  Min.Min[5] & 0x00007fff;
 131   MM.Max[2] =  Max.Min[5] & 0x00007fff;
 132   MM.Min[2] += (Min.Min[4] & 0x00007fff) << 16;
 133   MM.Max[2] += (Max.Min[4] & 0x00007fff) << 16;
 134   MM.Min[3] =  Min.Min[7] & 0x00007fff;
 135   MM.Max[3] =  Max.Min[7] & 0x00007fff;
 136   MM.Min[3] += (Min.Min[6] & 0x00007fff) << 16;
 137   MM.Max[3] += (Max.Min[6] & 0x00007fff) << 16;
 138   MM.Min[4] =  Min.Max[1] & 0x00007fff;
 139   MM.Max[4] =  Max.Max[1] & 0x00007fff;
 140   MM.Min[4] += (Min.Max[0] & 0x00007fff) << 16;
 141   MM.Max[4] += (Max.Max[0] & 0x00007fff) << 16;
 142   MM.Min[5] =  Min.Max[3] & 0x00007fff;
 143   MM.Max[5] =  Max.Max[3] & 0x00007fff;
 144   MM.Min[5] += (Min.Max[2] & 0x00007fff) << 16;
 145   MM.Max[5] += (Max.Max[2] & 0x00007fff) << 16;
 146   MM.Min[6] =  Min.Max[5] & 0x00007fff;
 147   MM.Max[6] =  Max.Max[5] & 0x00007fff;
 148   MM.Min[6] += (Min.Max[4] & 0x00007fff) << 16;
 149   MM.Max[6] += (Max.Max[4] & 0x00007fff) << 16;
 150   MM.Min[7] =  Min.Max[7] & 0x00007fff;
 151   MM.Max[7] =  Max.Max[7] & 0x00007fff;
 152   MM.Min[7] += (Min.Max[6] & 0x00007fff) << 16;
 153   MM.Max[7] += (Max.Max[6] & 0x00007fff) << 16;
 154 }
 155
 156 //=======================================================================
 157 //function : SizeBox
 158 //purpose  :
 159 //=======================================================================
 160
 161 Standard_Real HLRAlgo::SizeBox(HLRAlgo_EdgesBlock::MinMaxIndices& Min,
 162                                HLRAlgo_EdgesBlock::MinMaxIndices& Max)
 163 {
 164   Standard_Real s = Max.Min[0] - Min.Min[0];
 165   for (Standard_Integer aI = 1; aI < 8; ++aI)
 166   {
 167     s *= Max.Min[aI] - Min.Min[aI];
 168   }
 169   for (Standard_Integer aI = 0; aI < 6; ++aI)
 170   {
 171     s *= Max.Max[aI] - Min.Max[aI];
 172   }
 173   return s;
 174 }
 175
 176 //=======================================================================
 177 //function : DecodeMinMax
 178 //purpose  :
 179 //=======================================================================
 180
 181 void HLRAlgo::DecodeMinMax (const HLRAlgo_EdgesBlock::MinMaxIndices& MM,
 182                             HLRAlgo_EdgesBlock::MinMaxIndices& Min,
 183                             HLRAlgo_EdgesBlock::MinMaxIndices& Max)
 184 {
 185   Min.Min[0] =(MM.Min[0] & 0x7fff0000)>>16;
 186   Max.Min[0] =(MM.Max[0] & 0x7fff0000)>>16;
 187   Min.Min[1] = MM.Min[0] & 0x00007fff;
 188   Max.Min[1] = MM.Max[0] & 0x00007fff;
 189   Min.Min[2] =(MM.Min[1] & 0x7fff0000)>>16;
 190   Max.Min[2] =(MM.Max[1] & 0x7fff0000)>>16;
 191   Min.Min[3] = MM.Min[1] & 0x00007fff;
 192   Max.Min[3] = MM.Max[1] & 0x00007fff;
 193   Min.Min[4] =(MM.Min[2] & 0x7fff0000)>>16;
 194   Max.Min[4] =(MM.Max[2] & 0x7fff0000)>>16;
 195   Min.Min[5] = MM.Min[2] & 0x00007fff;
 196   Max.Min[5] = MM.Max[2] & 0x00007fff;
 197   Min.Min[6] =(MM.Min[3] & 0x7fff0000)>>16;
 198   Max.Min[6] =(MM.Max[3] & 0x7fff0000)>>16;
 199   Min.Min[7] = MM.Min[3] & 0x00007fff;
 200   Max.Min[7] = MM.Max[3] & 0x00007fff;
 201   Min.Max[0] =(MM.Min[4] & 0x7fff0000)>>16;
 202   Max.Max[0] =(MM.Max[4] & 0x7fff0000)>>16;
 203   Min.Max[1] = MM.Min[4] & 0x00007fff;
 204   Max.Max[1] = MM.Max[4] & 0x00007fff;
 205   Min.Max[2] =(MM.Min[5] & 0x7fff0000)>>16;
 206   Max.Max[2] =(MM.Max[5] & 0x7fff0000)>>16;
 207   Min.Max[3] = MM.Min[5] & 0x00007fff;
 208   Max.Max[3] = MM.Max[5] & 0x00007fff;
 209   Min.Max[4] =(MM.Min[6] & 0x7fff0000)>>16;
 210   Max.Max[4] =(MM.Max[6] & 0x7fff0000)>>16;
 211   Min.Max[5] = MM.Min[6] & 0x00007fff;
 212   Max.Max[5] = MM.Max[6] & 0x00007fff;
 213   Min.Max[6] =(MM.Min[7] & 0x7fff0000)>>16;
 214   Max.Max[6] =(MM.Max[7] & 0x7fff0000)>>16;
 215   Min.Max[7] = MM.Min[7] & 0x00007fff;
 216   Max.Max[7] = MM.Max[7] & 0x00007fff;
 217 }
 218
 219 //=======================================================================
 220 //function :AddMinMax
 221 //purpose  :
 222 //=======================================================================
 223
 224 void HLRAlgo::AddMinMax (HLRAlgo_EdgesBlock::MinMaxIndices& IMin,
 225                          HLRAlgo_EdgesBlock::MinMaxIndices& IMax,
 226                          HLRAlgo_EdgesBlock::MinMaxIndices& OMin,
 227                          HLRAlgo_EdgesBlock::MinMaxIndices& OMax)
 228 {
 229   OMin.Minimize(IMin);
 230   OMax.Maximize(IMax);
 231 }